yadriggy 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 990b3b201219b7511cbcf4554f24b3dc9bd14128
-  data.tar.gz: 6a45aaa8d3f036656f787d7979dbd7954f636d34
+  metadata.gz: f73ad8ceb3807a109ddbd4c11ddafee6f1854c32
+  data.tar.gz: 307556c77ee0760ddde8e55cece63d6975505ace
 SHA512:
-  metadata.gz: c295ef7bb85cefc84a43ac7459e28477e082bb28f093a797a1bde44fc02ac8578d802255bbb01f984056da4de554a1c6f9451a32d8b649b7122dacf25604bf36
-  data.tar.gz: 39b8d8ad06e9374558229724038f9db1f5edee7dc79f94fa3e470229784e3379dbf743754d6d731dcdbd9cf82f22bb1a046ad37d0cdb10aeb4d5976cacf05889
+  metadata.gz: a0922e73e77795a2d351887d3e9a11760b4e4ec5f8fb8535a440ef6cca8c707f0ad402805aec919a8f52f58fa1ae17c7c877549a6ee44119b0b0bf73cfce8ee0
+  data.tar.gz: 66d4ad0cdef21663929443687fb5d3e3f3b1f57a86c00fd35f38cd1b70f691a98f9a44515da17fb222c116072ea36152a7827f042695599c66e47e9fd2f74a5f

data/.yardopts

@@ -0,0 +1,3 @@
+--hide-api private
+--markup markdown
+lib/**/*.rb

data/README.md

@@ -2,22 +2,23 @@
 
 Yadriggy (mistletoe in Japanese) is a library for building a
 domain-specific language (DSL) embedded in Ruby.  It was developed for
-a particular kind of embedded DSLs, which we call hemiparasitic DSLs.
+a particular kind of embedded DSLs.
 These DSLs borrow the syntax from the host language, Ruby, and the
 code written in the DSLs is embedded in normal Ruby code.  However,
 the execution of the DSL code is independent of Ruby.  Its semantics
 can be totally different from Ruby and the code can be run out of the
-Ruby VM.  Hemiparasitic DSLs look like Ruby but they are different
+Ruby VM.  These DSLs look like Ruby but they are different
 languages except their syntax.
-They parasitize Ruby by borrowing the syntax but their parasitism is
-hemi; their execution engines are their own.
+They are embedded in Ruby by borrowing the syntax but their embedding is
+outward; their execution engines are their own.
 
 For details, the documentation is available from [Wiki](https://github.com/csg-tokyo/yadriggy/wiki).
 
-## Hemiparasitic DSLs
+## An example
 
-A typical example of hemiparasitic DSL is computation offloading from
-Ruby.  For example, Yadriggy provides a simple DSL to offload
+Computation offloading from Ruby is a typical example of the DSLs
+implemented by Yadriggy.
+For example, Yadriggy provides a simple DSL to offload
 from Ruby to native C language.
 
 ```ruby
@@ -30,7 +31,7 @@ def fib(n) ! Integer
   if n > 1
     return fib(n - 1) + fib(n - 2)
   else
-    return 1
+    return n
   end
 end
 
@@ -59,7 +60,7 @@ The variable `n` in the Ruby code keeps the old value.
 
 Note that the definition of `fib` contains type declarations
 since this DSL is not Ruby.
-A hemiparasitic DSL looks like Ruby but it is a different language.
+This DSL looks like Ruby but it is a different language.
 `! Integer` following `def fib(n)` specifies the return type.
 `typedecl` specifies the types of the parameters (and local variables
 if any).  In this DSL, most types have to be statically given
@@ -84,6 +85,8 @@ ast = Yadriggy.reify {|a| a + 1 }
 `reify` returns the AST of the given block `{|a| a + 1 }`.
 It takes not only a block but also a `Method` or `Proc` object.
 
+Yadriggy works with Pry and IRuby unless a syntax error occurs.
+
 The idea of `reify` was proposed in the following paper:
 
 - Shigeru Chiba, YungYu Zhuang, Maximilian Scherr, "Deeply Reifying Running Code for Constructing a Domain-Specific Language", PPPJ'16, Article No. 1, ACM, August 2016.

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "yard"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -7,4 +8,8 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
+YARD::Rake::YardocTask.new do |t|
+  t.options = ['-m markdown', '--no-private']
+end
+
 task :default => :test

data/lib/yadriggy.rb

@@ -25,7 +25,7 @@ module Yadriggy
   def self.debug() @@debug end
 
   # Sets the current debug level.
-  # @param [Integer] level.
+  # @param [Integer] level  the debug level.
   def self.debug=(level)
     @@debug = level
   end

data/lib/yadriggy/algebra.rb

@@ -113,8 +113,15 @@ module Yadriggy
       binary(left, op, right)
     end
 
+    # @param [Object|Array] left   the left value.
+    # @param [Symbol] op           the operator.
+    # @param [Object|Array] right  the right value.
     def assign(left, op, right)
-      binary(left, op, right)
+      if left.is_a?(Array) || right.is_a?(Array)
+        raise NotImplementedError.new('multiple assignment')
+      else
+        binary(left, op, right)
+      end
     end
 
     def array_ref(array, index)
@@ -259,13 +266,24 @@ module Yadriggy
     end
   end
 
-  # evaluator for Algebra
+  # Evaluator for Algebra
   #
   class EvalAlgebra < Eval
+    # Initializes.
+    #
+    # @param [Algebra] algebra
     def initialize(algebra)
       @algebra = algebra
     end
 
+    def evaluate(expr)
+      if expr.nil?
+        nil_value(nil)
+      else
+        expr.accept(self)
+      end
+    end
+
     def nil_value(expr)
       @algebra.nil_value
     end
@@ -355,7 +373,17 @@ module Yadriggy
     end
 
     def assign(expr)
-      @algebra.assign(evaluate(expr.left), expr.op, evaluate(expr.right))
+      right = if expr.right.is_a?(Array)
+                expr.right.map {|e| evaluate(e) }
+             else
+                evaluate(expr.right)
+             end
+      left = if expr.left.is_a?(Array)
+                expr.left.map {|e| evaluate(e) }
+             else
+                evaluate(expr.left)
+             end
+      @algebra.assign(left, expr.op, right)
     end
 
     def array_ref(expr)

data/lib/yadriggy/assert.rb

@@ -22,7 +22,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     def self.puts_reason(reason, evar=nil)
       puts '--- Yadriggy::Assert ---'
       print evar.cause.class.name, ': ' if evar&.cause
@@ -52,13 +52,13 @@ module Yadriggy
 
     # Reason that an assertion fails.
     class Reason
-      # @private
+      # @api private
       def setup(ast, results)
         @ast = ast
         @results = results
       end
 
-      # Gets the AST of the block given to {#assertion}.
+      # Gets the AST of the block given to {Yadriggy::Assert::assertion}.
       # @return [ASTnode] an abstract syntax tree.
       def ast() @ast end
 
@@ -85,7 +85,7 @@ module Yadriggy
         output.reverse!
       end
 
-      # @private
+      # @api private
       # @return [String] the new header.
       def show2(ast, header, output)
         if ast.is_a?(Paren)
@@ -136,7 +136,7 @@ module Yadriggy
         end
       end
 
-      # @private
+      # @api private
       # Obtains the text representation of the given value.
       def str_rep(v)
         max = 70
@@ -149,7 +149,7 @@ module Yadriggy
       end
     end
 
-    # Exception thrown by {#assertion}.
+    # Exception thrown by {Yadriggy::Assert#assertion}.
     #
     class AssertFailure < StandardError
       def initialize(reason, msg=nil, cause=nil)
@@ -167,7 +167,7 @@ module Yadriggy
       def reason() @reason end
     end
 
-    # @private
+    # @api 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.
@@ -210,7 +210,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api 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.

data/lib/yadriggy/ast.rb

@@ -16,11 +16,13 @@ module Yadriggy
   # the recorded ASTs are shared among {ASTree} objects.
   # Every call to {Yadriggy#reify} on {Yadriggy} makes a new table.  Hence,
   #
-  # <pre>ast1 = Yadriggy.reify(proc1)
+  # ```
+  # ast1 = Yadriggy.reify(proc1)
   # ast2 = ast.reify(proc2)
-  # a1 = Yadriggy.reify(proc1) # a1 != ast1
+  # a1 = Yadriggy.reify(proc1)  # a1 != ast1
   # a2 = a1.reify(proc2)        # a2 != ast2
-  # b2 = a1.reify(proc2)        # b2 == a2</pre>
+  # b2 = a1.reify(proc2)        # b2 == a2
+  # ```
   #
   # Although `ast1` and `a1`, and `ast2` and `a2` are different copies
   # of the AST of the same proc, `a2` and `b2` refer to the same AST.
@@ -136,7 +138,7 @@ module Yadriggy
     end
   end
 
-  # Reserved words such self, true, and false.
+  # Reserved words such as self, nil, true, and false.
   #
   class Reserved < Name
     def self.tag() :@kw end
@@ -324,7 +326,12 @@ module Yadriggy
 
     def initialize(sexp)
       if sexp[0] == :dyna_symbol
-        init(has_tag?(sexp[1][0], :@tstring_content))
+        sexp2 = if sexp[1][0] == :string_content
+                  sexp[1][1]
+                 else
+                  sexp[1][0]
+                 end
+        init(has_tag?(sexp2, :@tstring_content))
       elsif sexp[0] == :symbol_literal
         init(has_tag?(sexp[1], :symbol)[1])
       else
@@ -399,7 +406,8 @@ module Yadriggy
     def self.tag() :paren end
 
     def initialize(sexp)
-      @expression = to_node(sexp[1][0])
+      e = if sexp[1][0].is_a?(Array) then sexp[1][0] else sexp[1] end
+      @expression = to_node(e)
       add_child(@expression)
     end
 
@@ -424,6 +432,10 @@ module Yadriggy
     def initialize(sexp)
       if sexp[1].nil?
         @elements = []
+      elsif is_percent_literal(sexp[1])
+        @elements = sexp[1].map do |e|
+          StringInterpolation.new([:string_literal, [:string_content] + e])
+        end
       else
         @elements = to_nodes(sexp[1])
       end
@@ -436,6 +448,15 @@ module Yadriggy
     def accept(evaluator)
       evaluator.array(self)
     end
+
+    private
+
+    def is_percent_literal(sexp)
+      sexp.is_a?(Array) && sexp.size > 0 &&
+      sexp.all? do |e|
+        e.is_a?(Array) && e.all? {|ee| ee.is_a?(Array) }
+      end
+    end
   end
 
   # String interpolation.
@@ -673,25 +694,33 @@ module Yadriggy
   end
 
   # Assignment such as `=` and `+=`.
+  # `Assign#left` and `Assign#right` return an `ASTnode`,
+  # or an array of `ASTnode` if the node represents multiple
+  # assignment.
   #
   class Assign < Binary
-    def self.tags() [:assign, :opassign] end
+    def self.tags() [:assign, :opassign, :massign] end
 
     def initialize(sexp)
       case sexp[0]
       when :assign
         @left = to_node(sexp[1])
+        add_child(@left)
         @op = :'='
-        @right = to_node(sexp[2])
+        init_right(sexp[2])
       when :opassign
         @left = to_node(sexp[1])
+        add_child(@left)
         @op = has_tag?(sexp[2], :@op)[1].to_sym
-        @right = to_node(sexp[3])
+        init_right(sexp[3])
+      when :massign
+        @left = to_nodes(sexp[1])
+        add_children(@left)
+        @op = :'='
+        init_right(sexp[2])
       else
         raise "unknown assignment " + sexp[0].to_s
       end
-      add_child(@left)
-      add_child(@right)
     end
 
     # A method for Visitor pattern.
@@ -700,6 +729,19 @@ module Yadriggy
     def accept(evaluator)
       evaluator.assign(self)
     end
+
+    private
+
+    # @api private
+    def init_right(right_operand)
+      if right_operand[0] == :mrhs_new_from_args
+        @right = to_nodes(right_operand[1]) + [to_node(right_operand[2])]
+        add_children(@right)
+      else
+        @right = to_node(right_operand)
+        add_child(@right)
+      end
+    end
   end
 
   # Hash table.
@@ -792,7 +834,7 @@ module Yadriggy
                       parent, link_from_children)
     end
 
-    # @private
+    # @api private
     def initialize2(recv, op, name, args, barg, blk,
                     parent, link_from_children)
       @receiver = recv
@@ -826,6 +868,12 @@ module Yadriggy
         marg = sexp[1]
         if marg[0] == :method_add_arg
           initialize_method_arg(marg[1], marg[2])
+        elsif marg[0] == :command
+          initialize_call([:call, nil, nil, marg[1]])
+          initialize_args(marg[2]) if marg.length > 2
+        elsif marg[0] == :command_call
+          initialize_call([:call, marg[1], marg[2], marg[3]])
+          initialize_args(marg[4]) if marg.length > 4
         else
           initialize_method_arg(marg, [])
         end
@@ -865,13 +913,21 @@ module Yadriggy
     def initialize_call(sexp)
       @receiver = to_node(sexp[1])
       @op = sexp[2]	# :"." or :"::" or nil.
-      @name = to_node(has_tag?(sexp[3], :@ident))
+      @name = if sexp[3] == :call
+                nil
+              else
+                @name = to_node(has_tag?(sexp[3], :@ident))
+              end
       add_child(@receiver)
       add_child(@name)
     end
 
     def initialize_args(args_block)
-      args = has_tag?(args_block, :args_add_block)[1]
+      args = if args_block[0] == :args_add_block
+               args_block[1]
+             else
+               args_block
+             end
       args2 = initialize_star_arg(args)
       @args = to_nodes(args2)
       @block_arg = if args_block[2]
@@ -1652,7 +1708,7 @@ module Yadriggy
     end
   end
 
-  # @private
+  # @api private
   # A table of reified abstract syntax trees.
   # It is used for guaranteeing the uniqueness
   # of ASTree objects.

data/lib/yadriggy/ast_location.rb

@@ -27,7 +27,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     class GetLocation < EvalAll
       def initialize
         @unknown = true

data/lib/yadriggy/c/c.rb

@@ -95,7 +95,7 @@ module Yadriggy
       mod
     end
 
-    # @private
+    # @api private
     # @return [Pair<Module,Array<String>>]
     def self.compile0(obj, lib_name, dir, module_name,
                       typechecker_class, gen_class)
@@ -109,7 +109,7 @@ module Yadriggy
       end
     end
 
-    # @private
+    # @api private
     # @return [Pair<Module,Array<String>>]
     def self.compile1(obj, lib_name, dir, module_name,
                       typechecker_class, gen_class)
@@ -141,7 +141,7 @@ module Yadriggy
       attach_funcs(pub_methods, checker, gen, module_name, lib_name, dir)
     end
 
-    # @private
+    # @api private
     # @return [Array<ASTree>] the ASTs of compiled methods.
     def self.compiled_methods(checker, method_objs)
       ast = nil
@@ -165,7 +165,7 @@ module Yadriggy
       return pub_methods
     end
 
-    # @private
+    # @api private
     def self.generate_funcs(ast, gen, printer)
       gen.name_global_variables
       gen.headers
@@ -185,7 +185,7 @@ module Yadriggy
       raise BuildError.new(gen.error_messages) if gen.errors?
     end
 
-    # @private
+    # @api private
     # @return [Pair<Module,Array<String>>] the module where the methods
     #   are attached.  The second element is method names.
     def self.attach_funcs(pub_methods, checker, gen, module_name,