yadriggy 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa5e75505e86183390b717e3559e79528a06dab1
-  data.tar.gz: 6103b4d010e666693876526d6e425ae1bccf6a21
+  metadata.gz: 990b3b201219b7511cbcf4554f24b3dc9bd14128
+  data.tar.gz: 6a45aaa8d3f036656f787d7979dbd7954f636d34
 SHA512:
-  metadata.gz: cc3de4fdd6886598cefb8cfac86c8423cd5dda187d124b94495feae4bfd998d60f0f4d269cb659026bfa62625199ab284de67ec3690cc497004f0f7ff0fb0679
-  data.tar.gz: cd047b260fe5e66c1775f1532a51cfaf321304b309187ac7214d3d5f5110b05eead8f8806f91a6a810e84a4a361fd76778b36164eff4dbc9cee395c61f120522
+  metadata.gz: c295ef7bb85cefc84a43ac7459e28477e082bb28f093a797a1bde44fc02ac8578d802255bbb01f984056da4de554a1c6f9451a32d8b649b7122dacf25604bf36
+  data.tar.gz: 39b8d8ad06e9374558229724038f9db1f5edee7dc79f94fa3e470229784e3379dbf743754d6d731dcdbd9cf82f22bb1a046ad37d0cdb10aeb4d5976cacf05889

data/lib/yadriggy/algebra.rb

@@ -343,7 +343,7 @@ module Yadriggy
     end
 
     def unary(expr)
-      @algebra.unary(expr.op, evaluate(expr.expr))
+      @algebra.unary(expr.op, evaluate(expr.operand))
     end
 
     def binary(expr)

data/lib/yadriggy/assert.rb

@@ -0,0 +1,223 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy'
+
+module Yadriggy
+  # Power assert by Yadriggy
+  module Assert
+
+    # Checks the given assertion is correct and prints the result
+    # if the assertion fails.
+    #
+    # @param [Proc] block  the assertion.
+    def self.assert(&block)
+      reason = Reason.new
+      begin
+        res = assertion(reason, block)
+        puts_reason(reason) unless res
+        return res
+      rescue AssertFailure => evar
+        puts_reason(evar.reason, evar)
+        raise evar.cause
+      end
+    end
+
+    # @private
+    def self.puts_reason(reason, evar=nil)
+      puts '--- Yadriggy::Assert ---'
+      print evar.cause.class.name, ': ' if evar&.cause
+      puts evar.message if evar&.message
+      puts(reason.ast.source_location_string)
+      puts(reason.show)
+      puts '------------------------'
+    end
+
+    # Checks the given assertion is correct.
+    #
+    # @param [Reason] reason  the object where the reason that the assertion
+    #   fails will be stored.
+    # @param [Proc] block  the assertion.
+    # @return [Object] the result of executing the given block.
+    def self.assertion(reason, block)
+      return if block.nil?
+      ast = Yadriggy::reify(block)
+      begin
+        results = {}
+        reason.setup(ast.tree.body, results)
+        run_ast(ast.tree.body, block.binding, results)[1]
+      rescue => evar
+        raise AssertFailure.new(reason, evar.message, evar)
+      end
+    end
+
+    # Reason that an assertion fails.
+    class Reason
+      # @private
+      def setup(ast, results)
+        @ast = ast
+        @results = results
+      end
+
+      # Gets the AST of the block given to {#assertion}.
+      # @return [ASTnode] an abstract syntax tree.
+      def ast() @ast end
+
+      # Gets the detailed results.
+      # @return [Hash<ASTnode,Pair<String,Object>>]  a map from sub-expressions
+      #   to their source and resulting vales.  The sub-expressions are {ASTnode}
+      #   objects.
+      def results() @results end
+
+      # Gets the text showing the values of the sub-expressions.
+      # @return [Array<String>]  an array of lines.
+      def show
+        output = []
+        header = show2(@ast, '', output)
+        output << header
+        src, value = @results[ast]
+        if src.nil?
+          pp = PrettyPrinter.new(Printer.new(2))
+          pp.print(ast)
+          output << pp.printer.output
+        else
+          output << src
+        end
+        output.reverse!
+      end
+
+      # @private
+      # @return [String] the new header.
+      def show2(ast, header, output)
+        if ast.is_a?(Paren)
+          show2(ast.expression, header + ' ', output) + ' '
+        elsif ast.is_a?(Call) && ast.block_arg.nil? && ast.block.nil?
+          header2 = show2(ast.receiver, header, output)
+          src2, value2 = @results[ast.receiver]
+          src, value = @results[ast]
+          if src.nil?
+            src = PrettyPrinter.ast_to_s(ast)
+            if src2.nil?
+              "#{header}#{' ' * src.size}"
+            else
+              "#{header2}#{' ' * (src.size - src2.size)}"
+            end
+          else
+            output << "#{header2} #{str_rep(value)}"
+            "#{header2} |#{' ' * (src.size - src2.size - 2)}"
+          end
+        elsif ast.is_a?(Binary)
+          header = show2(ast.left, header, output)
+          src, value = @results[ast]
+          if src.nil?
+            header = header + '   '
+          else
+            output << "#{header} #{str_rep(value)}"
+            header = "#{header} | #{' ' * (ast.op.to_s.size - 1)}"
+          end
+          show2(ast.right, header, output)
+        elsif ast.is_a?(Unary)
+          src, value = @results[ast]
+          if src.nil?
+            header = header + ' '
+          else
+            output << "#{header}#{str_rep(value)}"
+            header = "#{header}|"
+          end
+          show2(ast.operand, header, output)
+        else
+          src, value = @results[ast]
+          if src.nil?
+            src = PrettyPrinter.ast_to_s(ast)
+            return "#{header}#{' ' * src.size}"
+          else
+            output << header + str_rep(value)
+            "#{header}|#{' ' * (src.size - 1)}"
+          end
+        end
+      end
+
+      # @private
+      # Obtains the text representation of the given value.
+      def str_rep(v)
+        max = 70
+        str = v.inspect
+        if str.length < max
+          str
+        else
+          str[0, max] + '...'
+        end
+      end
+    end
+
+    # Exception thrown by {#assertion}.
+    #
+    class AssertFailure < StandardError
+      def initialize(reason, msg=nil, cause=nil)
+        super(msg)
+        @reason = reason
+        @cause = cause
+      end
+
+      # Gets the cause.
+      # @return [StandardError] an exception.
+      def cause() @cause end
+
+      # Gets the reason.
+      # @return [Reason] the reason.
+      def reason() @reason end
+    end
+
+    # @private
+    # Executes the given AST and records the result.
+    # @param [ASTnode] ast  the given AST.
+    # @param [Binding] blk_binding  the binding for executing the AST.
+    # @param [Hash<ASTnode,Pair<String,Object>>] results  a map from ASTs
+    #   to their source and values.
+    # @return [Pair<String,Object>] the result of the execution of the given AST.
+    #   It is also recorded in `results`.
+    #   The first element is the source code and the second one is the resulting value.
+    def self.run_ast(ast, blk_binding, results)
+      if ast.is_a?(Paren)
+        res = run_ast(ast.expression, blk_binding, results)
+        src = "(#{res[0]})"
+        results[ast] = [src, res[1]]
+      elsif ast.is_a?(Call) && ast.block_arg.nil? && ast.block.nil?
+        if ast.receiver.nil?
+          receiver = ['self', blk_binding.eval('self')]
+        else
+          receiver = run_ast(ast.receiver, blk_binding, results)
+        end
+        args = ast.args.map {|e| run_ast(e, blk_binding, results) }
+        arg_values = args.map {|e| e[1] }
+        res = receiver[1].send(ast.name.name, *arg_values)
+        arg_src = args.each_with_object('') do |e, code|
+          code << ', ' if code.size > 0
+          code << e[0]
+        end
+        src = "#{receiver[0]}.#{ast.name.name.to_s}(#{arg_src.to_s})"
+        results[ast] = [src, res]
+      elsif ast.is_a?(Binary)
+        left_value = run_ast(ast.left, blk_binding, results)
+        right_value = run_ast(ast.right, blk_binding, results)
+        res = left_value[1].send(ast.op, right_value[1])
+        results[ast] = ["#{left_value[0]} #{ast.op.to_s} #{right_value[0]}", res]
+      elsif ast.is_a?(Unary)
+        value = run_ast(ast.operand, blk_binding, results)
+        res = value[1].send(ast.op)
+        results[ast] = ["#{ast.real_operator.to_s}#{value[0]}", res]
+      else
+        results[ast] = eval_by_ruby(ast, blk_binding)
+      end
+    end
+
+    # @private
+    # Eval the AST by the RubyVM
+    # @return [Pair<String,Object>]  an array.  The first element is the source code
+    #   and the second element is the resulting value.
+    def self.eval_by_ruby(ast, blk_binding)
+      src = PrettyPrinter.ast_to_s(ast)
+      loc = ast.source_location
+      [src, eval(src, blk_binding, loc[0], loc[1])]
+    end
+  end
+end

data/lib/yadriggy/ast.rb

@@ -587,14 +587,14 @@ module Yadriggy
     attr_reader :op
 
     # @return [ASTnode] the operand.
-    attr_reader :expr
+    attr_reader :operand
 
     def self.tag() :unary end
 
     def initialize(sexp)
       @op = sexp[1]
-      @expr = to_node(sexp[2])
-      add_child(@expr)
+      @operand = to_node(sexp[2])
+      add_child(@operand)
     end
 
     # Returns the real operator name.

data/lib/yadriggy/ast_value.rb

@@ -326,19 +326,19 @@ module Yadriggy
 
   class Unary
     def value()
-      send_op_to_value(@expr.value)
+      send_op_to_value(@operand.value)
     end
 
     def value_in_class(klass)
-      send_op_to_value(@expr.value_in_class(klass))
+      send_op_to_value(@operand.value_in_class(klass))
     end
 
     def const_value()
-      send_op_to_value(@expr.const_value)
+      send_op_to_value(@operand.const_value)
     end
 
     def const_value_in_class(klass)
-      send_op_to_value(@expr.const_value_in_class(klass))
+      send_op_to_value(@operand.const_value_in_class(klass))
     end
 
     private
@@ -357,7 +357,7 @@ module Yadriggy
     end
 
     def value_in_class(klass)
-      send_op_to_value(@expr.value_in_class(klass),
+      send_op_to_value(@left.value_in_class(klass),
                        @right.value_in_class(klass))
     end
 
@@ -366,7 +366,7 @@ module Yadriggy
     end
 
     def const_value_in_class(klass)
-      send_op_to_value(@expr.const_value_in_class(klass),
+      send_op_to_value(@left.const_value_in_class(klass),
                        @right.const_value_in_class(klass))
     end
 

data/lib/yadriggy/c/c.rb

@@ -57,7 +57,7 @@ module Yadriggy
       typedecl   <= Call +
                    { name: typedecl_name, args: [ typedecl_hash ] }
 
-      return_type <= Unary + { expr: Const | ConstPathRef | arrayof }
+      return_type <= Unary + { operand: Const | ConstPathRef | arrayof }
       func_body  <= return_type | stmnt |
                     Exprs + { expressions: [ (return_type), stmnt ] }
 

data/lib/yadriggy/c/codegen.rb

@@ -134,7 +134,7 @@ module Yadriggy
 
       rule(Unary) do
         @printer << ast.real_operator.to_s
-        check(ast.expr)
+        check(ast.operand)
       end
 
       rule(Binary) do
@@ -153,7 +153,7 @@ module Yadriggy
       end
 
       rule(Dots) do
-        error(expr, 'a range object is not available')
+        error(ast, 'a range object is not available')
       end
 
       rule(Call) do

data/lib/yadriggy/c/ctypecheck.rb

@@ -143,7 +143,7 @@ module Yadriggy
       end
 
       rule(:return_type) do
-        typedecl_type(ast.expr)
+        typedecl_type(ast.operand)
       end
 
       rule(Number) do
@@ -248,7 +248,7 @@ module Yadriggy
       end
 
       rule(Unary) do
-        t = type(ast.expr)
+        t = type(ast.operand)
         type_assert(ast.op == :-@, "bad operator: #{ast.op}")
         t
       end

data/lib/yadriggy/eval_all.rb

@@ -43,7 +43,7 @@ module Yadriggy
     end
 
     def unary(expr)
-      evaluate(expr.expr)
+      evaluate(expr.operand)
     end
 
     def binary(expr)

data/lib/yadriggy/pretty_print.rb

@@ -103,7 +103,7 @@ module Yadriggy
 
     rule(Unary) do
       @printer << ast.real_operator
-      print(ast.expr)
+      print(ast.operand)
     end
 
     rule(Binary) do

data/lib/yadriggy/ruby_typecheck.rb

@@ -121,7 +121,7 @@ module Yadriggy
     end
 
     rule(Unary) do
-      type(ast.expr)
+      type(ast.operand)
     end
 
     rule(Binary) do

data/lib/yadriggy/ruby_typeinfer.rb

@@ -169,7 +169,7 @@ module Yadriggy
 
     # +@, -@, !, ~, not
     rule(Unary) do
-      expr_t = type(ast.expr)
+      expr_t = type(ast.operand)
       op = ast.op
       if op == :! || op == :not
         RubyClass::Boolean
@@ -178,7 +178,7 @@ module Yadriggy
             ((op == :+@ || op == :-@) && expr_t <= RubyClass::Numeric)
           expr_t
         else
-          call_expr = Call.make(receiver: ast.expr, name: op,
+          call_expr = Call.make(receiver: ast.operand, name: op,
                                 parent: ast.parent)
           get_call_expr_type(call_expr, type_env, op)
         end

data/lib/yadriggy/syntax.rb

@@ -477,7 +477,7 @@ module Yadriggy
         ArrayRefField  <= ArrayRef
         Assign     <= Binary
         Dots       <= Binary
-        Unary      <= { op: Symbol, expr: expr }
+        Unary      <= { op: Symbol, operand: expr }
         ConstPathRef   <= { scope: (ConstPathRef | Const), name: Const }
         ConstPathField <= ConstPathRef
         StringLiteral  <= { value: String }

data/lib/yadriggy/version.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
 
 module Yadriggy
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yadriggy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Shigeru Chiba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-02 00:00:00.000000000 Z
+date: 2018-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -96,6 +96,7 @@ files:
 - Rakefile
 - lib/yadriggy.rb
 - lib/yadriggy/algebra.rb
+- lib/yadriggy/assert.rb
 - lib/yadriggy/ast.rb
 - lib/yadriggy/ast_location.rb
 - lib/yadriggy/ast_value.rb
@@ -108,7 +109,6 @@ files:
 - lib/yadriggy/c/ffi.rb
 - lib/yadriggy/c/opencl.rb
 - lib/yadriggy/c/program.rb
-- lib/yadriggy/c1.rb
 - lib/yadriggy/checker.rb
 - lib/yadriggy/eval.rb
 - lib/yadriggy/eval_all.rb

data/lib/yadriggy/c1.rb

@@ -1,10 +0,0 @@
-# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
-
-require 'yadriggy'
-require 'yadriggy/c1/c1'
-
-module Yadriggy
-  # Simple C language
-  module C1
-  end
-end