yadriggy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aa5e75505e86183390b717e3559e79528a06dab1
+  data.tar.gz: 6103b4d010e666693876526d6e425ae1bccf6a21
+SHA512:
+  metadata.gz: cc3de4fdd6886598cefb8cfac86c8423cd5dda187d124b94495feae4bfd998d60f0f4d269cb659026bfa62625199ab284de67ec3690cc497004f0f7ff0fb0679
+  data.tar.gz: cd047b260fe5e66c1775f1532a51cfaf321304b309187ac7214d3d5f5110b05eead8f8806f91a6a810e84a4a361fd76778b36164eff4dbc9cee395c61f120522

data/.gitignore

@@ -0,0 +1,13 @@
+*~
+.idea
+.DS_Store
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/testbin/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yadriggy.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018- Shigeru Chiba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# Yadriggy
+
+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.
+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
+languages except their syntax.
+They parasitize Ruby by borrowing the syntax but their parasitism is
+hemi; their execution engines are their own.
+
+For details, the documentation is available from [Wiki](https://github.com/csg-tokyo/yadriggy/wiki).
+
+## Hemiparasitic DSLs
+
+A typical example of hemiparasitic DSL is computation offloading from
+Ruby.  For example, Yadriggy provides a simple DSL to offload
+from Ruby to native C language.
+
+```ruby
+require 'yadriggy/c'
+
+include Yadriggy::C::CType
+
+def fib(n) ! Integer
+  typedecl n: Integer
+  if n > 1
+    return fib(n - 1) + fib(n - 2)
+  else
+    return 1
+  end
+end
+
+puts Yadriggy::C.run { return fib(32) }
+```
+
+When this code is run, the block given to `Yadriggy::C.run` is
+translated into C code with the definition of `fib` method.
+Then the C code is compiled into a dynamic library, loaded the
+library through ruby-ffi, and executed.  Since the block given to
+`run` calls `fib`, the definition of `fib` is also translated
+into C.
+
+An external variable is accessible from the compiled block:
+
+```ruby
+n = 32
+puts Yadriggy::C.run { return fib(n) }
+```
+
+The argument to `fib` is take from the variable `n` that exists
+outside of the block.  `n` is passed to the compiled block by _copying_.
+It is not passed by _reference_.  Thus, when a new value is assigned to
+`n` within the compiled block, it is not visible from the Ruby code.
+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.
+`! 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
+although the DSL performs simple type inference and some types
+can be omitted.
+
+## Library
+
+Yadriggy provides a method for obtaining the abstract syntax tree (AST)
+of the given method, lambda, or Proc.
+It also provides a syntax checker that determines whether or not an AST
+satisfies the syntax described in the BNF-like language, which is
+a DSL embedded in Ruby by Yadriggy.
+
+You can even obtain the AST of a piece of source code:
+
+```ruby
+require 'yadriggy'
+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.
+
+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.
+
+## Installation
+
+To install, run:
+
+    $ gem install yadriggy
+
+or, download this repository and run:
+
+    $ bundle exec rake install
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/csg-tokyo/yadriggy.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/yadriggy.rb

@@ -0,0 +1,32 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/version'
+
+require 'yadriggy/source_code'
+require 'yadriggy/ast'
+require 'yadriggy/ast_value'
+require 'yadriggy/ast_location'
+require 'yadriggy/eval'
+require 'yadriggy/eval_all'
+require 'yadriggy/algebra'
+require 'yadriggy/syntax'
+require 'yadriggy/checker'
+require 'yadriggy/typecheck'
+require 'yadriggy/ruby_typecheck'
+require 'yadriggy/ruby_typeinfer'
+require 'yadriggy/printer'
+require 'yadriggy/pretty_print'
+
+module Yadriggy
+  @@debug = 0
+
+  # Current debug level (0, 1, or 2).
+  # @return [Integer] the current level.
+  def self.debug() @@debug end
+
+  # Sets the current debug level.
+  # @param [Integer] level.
+  def self.debug=(level)
+    @@debug = level
+  end
+end

data/lib/yadriggy/algebra.rb

@@ -0,0 +1,497 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/eval'
+
+module Yadriggy
+
+  # An interface inspired by object algebra (and tag-less final)
+  #
+  class Algebra
+
+    def initialize(expr)
+      EvalAlgebra.new(self).evaluate(expr)
+    end
+
+    def nil_value()
+      raise NotImplementedError.new('nil_value')
+    end
+
+    def name(name, line_no, column)
+      raise NotImplementedError.new('name')
+    end
+
+    def identifier_or_call(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def identifier(name, line_no, column)
+      identifier_or_call(name, line_no, column)
+    end
+
+    def reserved(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def const(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def label(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def symbol(name, line_no, column)
+      raise NotImplementedError.new('symbol')
+    end
+
+    def global_variable(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def instance_variable(name, line_no, column)
+      name(name, line_no, column)
+    end
+
+    def variable_call(name, line_no, column)
+      identifier_or_call(name, line_no, column)
+    end
+
+    def super_method(expr)
+      raise NotImplementedError.new('super_method')
+    end
+
+    def number(value, line_no, column)
+      raise NotImplementedError.new('number')
+    end
+
+    # exprs() sequentially processes each expression in a series
+    # of expressions.
+    # So, for example, { e1, e2, ..., e_n } is
+    # processed by exprs(.. exprs(exprs(nil, e1), e2).., e_n).
+    # In other words, it is by
+    # [e1, e2, ..., e_n].inject(nil) {|r,e| exprs(r, evaluate(e))}.
+    #
+    # RESULT specifies the result of the previous expression.
+    # It is nil if EXPR is the first expression.
+    #
+    def exprs(result, expr)
+      raise NotImplementedError.new('exprs')
+    end
+
+    # CONTENTS is an array of the results of evaluating
+    # each component.
+    #
+    def string_interpolation(contents)
+      raise NotImplementedError.new('string_interpolation')
+    end
+
+    def string_literal(value, line_no, column)
+      raise NotImplementedError.new('string_literal')
+    end
+
+    # A constant value in a scope, such as Foo::Bar.
+    #
+    def const_path_ref(scope, name)
+      raise NotImplementedError.new('const_path_ref')
+    end
+
+    # A constant value in a scope as a L-value.
+    #
+    def const_path_field(scope, name)
+      const_path_ref(scope, name)
+    end
+
+    def unary(op, expr)
+      raise NotImplementedError.new('unary')
+    end
+
+    def binary(left, op, right)
+      raise NotImplementedError.new('binary')
+    end
+
+    def dots(left, op, right)
+      binary(left, op, right)
+    end
+
+    def assign(left, op, right)
+      binary(left, op, right)
+    end
+
+    def array_ref(array, index)
+      raise NotImplementedError.new('array')
+    end
+
+    # Array reference as L-value
+    #
+    def array_ref_field(array, index)
+      array_ref(array, index)
+    end
+
+    # An expression surrounded with ().
+    #
+    def paren(element)
+      raise NotImplementedError.new('paren')
+    end
+
+    # An array literal.
+    # ELEMENTS is an array.
+    #
+    def array(elements)
+      raise NotImplementedError.new('array')
+    end
+
+    # PAIRS is an array of pairs.  Each pair is
+    # an array where the first element is a key
+    # and the second element is a value.
+    #
+    def hash(pairs)
+      raise NotImplementedError.new('hash')
+    end
+
+    # Method call.
+    # ARGS is an array.  BLOCK is a thunk.
+    #
+    def call(receiver, op, name, args, block_arg, block)
+      raise NotImplementedError.new('call')
+    end
+
+    # Method call without parentheses.
+    # ARGS is an array.  BLOCK is a thunk.
+    #
+    def command(receiver, op, name, args, block_arg, block)
+      call(receiver, op, name, args, block_arg, block)
+    end
+
+    # if, unless, modifier if/unless, and ternary if (?:)
+    # THEN_EXPRS is a thunk.
+    # ALL_ELSIF is an array of pairs of elsif condition and its body.
+    # Both are thunks.
+    # ELSE_EXPRS is a thiuk or nil.
+    #
+    def conditional(op, cond, then_exprs, all_elsif, else_exprs)
+      raise NotImplementedError.new('conditional')
+    end
+
+    # while, until, and modifier while/until.
+    # COND and BODY are thunks.
+    #
+    def loop(op, cond, body)
+      raise NotImplementedError.new('loop')
+    end
+
+    # for loop.
+    # BODY is a thunk.
+    #
+    def for_loop(var, set, body)
+      raise NotImplementedError.new('for_loop')
+    end
+
+    # break, next, redo, retry.
+    #
+    def break_out(op, values)
+      raise NotImplementedError.new('break_out')
+    end
+
+    # An expression with return.
+    #
+    def return_values(values)
+      raise NotImplementedError.new('return_values')
+    end
+
+    # A block.
+    # BODY is a thunk.
+    #
+    def block(params, optionals, rest_params, params_after_rest, keywords,
+              rest_of_keywords, block_param, body)
+      raise NotImplementedError.new('block')
+    end
+
+    # A lambda expression.
+    # BODY is a thunk.
+    #
+    def lambda_expr(params, optionals, rest_params, params_after_rest,
+                    keywords, rest_of_keywords, block_param, body)
+      block(params, optionals, rest_params, params_after_rest,
+            keywords, rest_of_keywords, block_param, body)
+    end
+
+    # rescue-else-ensure-end.
+    # BODY, NESTED_RESCUE, ELSE_CLAUSE, and ENSURE_CLAUSE are
+    # thunks.
+    #
+    def rescue_end(types, parameter, body, nested_rescue,
+                   else_clause, ensure_clause)
+      raise NotImplementedError.new('rescue_end')
+    end
+
+    def begin_end(body, rescue_clause)
+      raise NotImplementedError.new('begin_end')
+    end
+
+    # def.
+    #
+    # BODY and RESCUE_CLAUSE are thunks.
+    #
+    def define(name, params, optionals, rest_of_params, params_after_rest,
+               keywords, rest_of_keywords, block_param,
+               body, rescue_clause)
+      raise NotImplementedError.new('define')
+    end
+
+    def module_def(name, body, rescue_clause)
+      raise NotImplementedError.new('module_def')
+    end
+
+    def class_def(name, superclass, body, rescue_clause)
+      raise NotImplementedError.new('class_def')
+    end
+
+    def singular_class_def(name, body, rescue_clause)
+      raise NotImplementedError.new('singular_class_def')
+    end
+
+    # A whole program.
+    #
+    # ELEMENTS is the result of processing the program elements.
+    #
+    def program(elements)
+      raise NotImplementedError.new('program')
+    end
+  end
+
+  # evaluator for Algebra
+  #
+  class EvalAlgebra < Eval
+    def initialize(algebra)
+      @algebra = algebra
+    end
+
+    def nil_value(expr)
+      @algebra.nil_value
+    end
+
+    def name(expr)
+      raise  'should never happen'
+    end
+
+    def identifier(expr)
+      @algebra.identifier(expr.name, expr.line_no, expr.column)
+    end
+
+    def reserved(expr)
+      @algebra.reserved(expr.name, expr.line_no, expr.column)
+    end
+
+    def const(expr)
+      @algebra.const(expr.name, expr.line_no, expr.column)
+    end
+
+    def label(expr)
+      @algebra.label(expr.name, expr.line_no, expr.column)
+    end
+
+    def symbol(expr)
+      @algebra.symbol(expr.name, expr.line_no, expr.column)
+    end
+
+    def global_variable(expr)
+      @algebra.global_variable(expr.name, expr.line_no, expr.column)
+    end
+
+    def instance_variable(expr)
+      @algebra.instance_variable(expr.name, expr.line_no, expr.column)
+    end
+
+    def variable_call(expr)
+      @algebra.variable_call(expr.name, expr.line_no, expr.column)
+    end
+
+    def super_method(expr) @algebra.super_method end
+
+    def number(expr)
+      @algebra.number(expr.value, expr.line_no, expr.column)
+    end
+
+    def exprs(expr)
+      expr.expressions.inject(nil) do |result, e|
+        @algebra.exprs(result, evaluate(e))
+      end
+    end
+
+    def paren(expr)
+      @algebra.paren(evaluate(expr.expression))
+    end
+
+    def array(expr)
+      @algebra.array(expr.elements.map {|e| evaluate(e)})
+    end
+
+    def string_interpolation(expr)
+      @algebra.string_interpolation(expr.contents.map {|e| evaluate(e) })
+    end
+
+    def string_literal(expr)
+      @algebra.string_literal(expr.value, expr.line_no, expr.column)
+    end
+
+    def const_path_ref(expr)
+      @algebra.const_path_ref(expr.scope, expr.name)
+    end
+
+    def const_path_field(expr)
+      @algebra.const_path_field(expr.scope, expr.name)
+    end
+
+    def unary(expr)
+      @algebra.unary(expr.op, evaluate(expr.expr))
+    end
+
+    def binary(expr)
+      @algebra.binary(evaluate(expr.left), expr.op, evaluate(expr.right))
+    end
+
+    def dots(expr)
+      @algebra.dots(evaluate(expr.left), expr.op, evaluate(expr.right))
+    end
+
+    def assign(expr)
+      @algebra.assign(evaluate(expr.left), expr.op, evaluate(expr.right))
+    end
+
+    def array_ref(expr)
+      @algebra.array_ref(evaluate(expr.array),
+                         expr.indexes.map {|e| evaluate(e) })
+    end
+
+    def array_ref_field(expr)
+      @algebra.array_ref_field(evaluate(expr.array),
+                               expr.indexes.map {|e| evaluate(e) })
+    end
+
+    def hash(expr)
+      @algebra.hash(expr.pairs.map {|p| p.map {|e| evaluate(e) }})
+    end
+
+    def call(expr)
+      @algebra.call(evaluate(expr.receiver), expr.op, expr.name,
+                    expr.args.map {|e| evaluate(e) },
+                    evaluate(expr.block_arg),
+                    lambda { evaluate(expr.block) })
+    end
+
+    def command(expr)
+      @algebra.command(evaluate(expr.receiver), expr.op, expr.name,
+                       expr.args.map {|e| evaluate(e) },
+                       evaluate(expr.block_arg),
+                       lambda { evaluate(expr.block) })
+    end
+
+    def conditional(expr)
+      @algebra.conditional(expr.op, evaluate(expr.cond),
+                           lambda { evaluate(expr.then) },
+                           expr.all_elsif.map do |e|
+                             [lambda { evaluate(e[0]) },
+                              lambda { evaluate(e[1]) }]
+                           end,
+                           if expr.else.nil?
+                             nil
+                           else
+                             lambda { evaluate(expr.else) }
+                           end)
+    end
+
+    def loop(expr)
+      @algebra.loop(expr.op, lambda { evaluate(expr.cond) },
+                    lambda { evaluate(expr.body) })
+    end
+
+    def for_loop(expr)
+      @algebra.for_loop(expr.vars, evaluate(expr.set),
+                        lambda { evaluate(expr.body) })
+    end
+
+    def break_out(expr)
+      @algebra.break_out(expr.op, expr.values.map {|e| evaluate(e) })
+    end
+
+    def return_values(expr)
+      @algebra.return_values(expr.values.map {|e| evaluate(e) })
+    end
+
+    def block(expr)
+      @algebra.block(expr.params, expr.optionals, expr.rest_of_params,
+                     expr.params_after_rest, expr.keywords,
+                     expr.rest_of_keywords,
+                     expr.block_param, lambda { evaluate(expr.body) })
+    end
+
+    def lambda_expr(expr)
+      @algebra.lambda_expr(expr.params, expr.optionals, expr.rest_of_params,
+                           expr.params_after_rest, expr.keywords,
+                           expr.rest_of_keywords,
+                           expr.block_param, lambda { evaluate(expr.body) })
+    end
+
+    def rescue_end(expr)
+      @algebra.rescue_end(expr.types, expr.parameter,
+                          lambda { evaluate(expr.body) },
+                          lambda { evaluate(expr.nested_rescue) },
+                          lambda { evaluate(expr.else) },
+                          lambda { evaluate(expr.ensure) })
+    end
+
+    def begin_end(expr)
+      @algebra.begin_end(lambda { evaluate(expr.body) },
+                      if expr.rescue.nil?
+                        nil
+                      else
+                        lambda { evaluate(expr.rescue) }
+                      end)
+    end
+
+    def define(expr)
+      @algebra.define(expr.name, expr.params, expr.optionals,
+                      expr.rest_of_params, expr.params_after_rest,
+                      expr.keywords, expr.rest_of_keywords,
+                      expr.block_param, lambda { evaluate(expr.body) },
+                      if expr.rescue.nil?
+                        nil
+                      else
+                        lambda { evaluate(expr.rescue) }
+                      end)
+    end
+
+    def module_def(expr)
+      @algebra.module_def(expr.name, lambda { evaluate(expr.body) },
+                          if expr.rescue.nil?
+                            nil
+                          else
+                            lambda { evaluate(expr.rescue) }
+                          end)
+    end
+
+    def class_def(expr)
+      @algebra.class_def(expr.name, expr.superclass,
+                         lambda { evaluate(expr.body) },
+                          if expr.rescue.nil?
+                            nil
+                          else
+                            lambda { evaluate(expr.rescue) }
+                          end)
+    end
+
+    def singular_class_def(expr)
+      @algebra.singular_class_def(expr.name,
+                                  lambda { evaluate(expr.body) },
+                                  if expr.rescue.nil?
+                                    nil
+                                  else
+                                    lambda { evaluate(expr.rescue) }
+                                  end)
+    end
+
+    def program(expr)
+      @algebra.program(evaluate(expr.elements))
+    end
+  end
+end