yadriggy 1.0.0

data/lib/yadriggy/c/program.rb

@@ -0,0 +1,86 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/c/c'
+require 'yadriggy/c/config'
+
+module Yadriggy
+  module C
+    class Program
+      include Yadriggy::C::CType
+
+      # Compiles this class and makes a module including the
+      # compiled methods.
+      #
+      # @param [String] module_name  the name of the module where
+      #  methods are attached.  If it is not nil, a Ruby script
+      #  is generated.  When it is executed later, the methods are
+      #  attached to the module with `module_name`.
+      #  The name of the generated Ruby script is `#{lib_name}.rb`.
+      # @param [String] lib_name  the name of the generated library.
+      # @param [String] dir  the directory name where generated files
+      #   are stored.
+      # @return [Module] the module where methods are attached.
+      #   Note that the name of this module is nil.
+      #   It is not `method_name`.
+      def self.compile(module_name=nil, lib_name=nil, dir: Config::WorkDir)
+        obj = self.new
+        Yadriggy::C.compile(obj, lib_name, dir, module_name)
+      end
+
+      # Prints arguments.  This method is available from C code.
+      # It takes arguments as `printf` in C.  For example,
+      # `printf('value %d', 7)` is a valid call.
+      # Note that the argument types are not checked.
+      def printf(s) ! Void
+        typedecl s: String, foreign: Void
+        puts s
+      end
+
+      # Gets the current time in micro sec.
+      # @return [Time] the current time.  In C, an integer is returned.
+      def current_time() ! Int
+        typedecl native: "struct timespec time;\n\
+clock_gettime(CLOCK_MONOTONIC, &time);\n\
+return time.tv_sec * 1000000 + time.tv_nsec / 1000;"
+        Time.now * 1000000
+      end
+
+      # Square root function with single precision.
+      def sqrtf(f)
+        typedecl f: Float, foreign: Float
+        Math.sqrt(f)
+      end
+
+      # Square root function.
+      def sqrt(f)
+        typedecl f: Float, foreign: Float
+        Math.sqrt(f)
+      end
+
+      # Exponential function with single precision.
+      def expf(f)
+        typedecl f: Float, foreign: Float
+        Math.exp(f)
+      end
+
+      # Exponential function.
+      def exp(f)
+        typedecl f: Float, foreign: Float
+        Math.exp(f)
+      end
+
+      # Logarithm function with single precision.
+      def logf(f)
+        typedecl f: Float, foreign: Float
+        Math.log(f)
+      end
+
+      # Logarithm function.
+      def log(f)
+        typedecl f: Float, foreign: Float
+        Math.log(f)
+      end
+
+    end
+  end
+end

data/lib/yadriggy/c1.rb

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

data/lib/yadriggy/checker.rb

@@ -0,0 +1,216 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+require 'yadriggy/ast'
+
+module Yadriggy
+
+  # Exception thrown by a checker.
+  class CheckError < RuntimeError
+  end
+
+  # AST checker.
+  # It visits the AST nodes and does various checks like type checking.
+  class Checker
+    include Yadriggy
+
+    # Defines the rule for a node type.
+    #
+    # @param [Class] node_type    the type of the AST node.
+    # @yield The block is executed for the node with `node_type`.
+    # @return [void]
+    def self.rule(node_type, &proc)
+      init_class if @rules.nil?
+      @rules[node_type] = proc
+      @rule_declarators[node_type] = self
+    end
+
+    # @private
+    # Initializes this class if necessary.
+    def self.check_init_class
+      init_class if @rules.nil?
+    end
+
+    # @private
+    # @return [Array<Hash>] all the rules defined so far.
+    def self.all_rules
+      [@rules, @rule_declarators]
+    end
+
+    private_class_method def self.init_class
+      @rules = {}
+      @rule_declarators = {}
+      unless self.superclass == Object
+        all = self.superclass.all_rules
+        unless all[0].nil?
+          @rules = all[0].clone
+          @rule_declarators = all[1].clone
+        end
+      end
+    end
+
+    # @private
+    # internal-use only.  Don't call this.
+    # @return [Pair<Proc,Class>] a rule and the class declaring it, or nil.
+    #
+    def self.find_rule_entry(ast)
+      find_rule_entry2(ast.class, ast.usertype)
+    end
+
+    private_class_method def self.find_rule_entry2(ast_class, utype)
+      unless utype.nil?
+        rule = @rules[utype]
+        return [rule, @rule_declarators[utype]] unless rule.nil?
+      end
+
+      rule = @rules[ast_class]
+      if rule.nil?
+        if ast_class.superclass.nil?
+          nil
+        else
+          find_rule_entry2(ast_class.superclass, utype)
+        end
+      else
+        [rule, @rule_declarators[ast_class]]
+      end
+    end
+
+    # Initializes the object.
+    def initialize
+      self.class.check_init_class
+      @error = nil
+      @check_list = []
+      @current_ast = nil
+      @current_env = nil
+      @rule_declarator = nil
+    end
+
+    # @return [String] an error message when the last invocation of check()
+    # returns nil.
+    def error
+      @error || ''
+    end
+
+    # Applies rules to the given AST.
+    # It returns the result of the rule-application or throws
+    # a CheckError.
+    # This is the entry point of the checker.  It may also
+    # check the other ASTs invoked in the given AST.
+    #
+    # @param [ASTree|ASTnode] an_ast  the AST.
+    # @return [Object]
+    def check_all(an_ast)
+      return nil if an_ast.nil?
+      an_ast = an_ast.tree if an_ast.is_a?(ASTree)
+      t = check(an_ast, make_base_env(an_ast.get_context_class))
+      until (checked = @check_list.pop).nil?
+        @current_ast = checked[0]
+        @current_env = checked[1]
+        checked[2].call
+      end
+      t
+    end
+
+    # Makes a new base environment with the given context class.
+    # @param [Module] klass  the context class.
+    def make_base_env(klass)
+      klass
+    end
+
+    # Applies rules to the given AST.
+    #
+    # It assumes that ast is processed by Syntax and it has usertype method.
+    # An exception is thrown when the checking fails.
+    # ast may be nil.
+    #
+    # The environment given to this method can be accessed in the rules
+    # through ast_env().  It is optional and can be any object.
+    # The initial one is made by make_base_env().
+    #
+    # @return [Object]
+    def check(an_ast, ast_env=nil)
+      if an_ast.nil?
+        nil
+      else
+        rule = self.class.find_rule_entry(an_ast)
+        apply_typing_rule(rule, an_ast, ast_env)
+      end
+    end
+
+    # @private
+    # internal use only
+    def apply_typing_rule(rule, an_ast, ast_tenv)
+      if rule.nil?
+        error_found!(an_ast, "no typing rule for #{an_ast.class}")
+      else
+        old_ast = @current_ast
+        old_tenv = @current_env
+        old_declarator = @rule_declarator
+        @current_ast = an_ast
+        @current_env = ast_tenv unless ast_tenv.nil?
+        @rule_declarator = rule[1]
+        t = instance_exec(&rule[0])
+        @rule_declarator = old_declarator
+        @current_env = old_tenv
+        @current_ast = old_ast
+        return t
+      end
+    end
+
+    # Applies the rule supplied by the superclass.
+    # @param [ASTnode] an_ast  an AST.
+    # @param [Object] envi  an environment object.
+    # @return [Type] the type of the given AST.
+    def proceed(an_ast, envi=nil)
+      rule = if @rule_declarator&.superclass == Object
+               nil
+             else
+               @rule_declarator&.superclass.find_rule_entry(an_ast)
+             end
+      if rule.nil?
+        error_found!(an_ast, 'no more rule. we cannot proceed')
+      else
+        apply_typing_rule(rule, an_ast, envi)
+      end
+    end
+
+    # @return [ASTnode] the current abstract syntax tree.
+    def ast
+      @current_ast
+    end
+
+    # @return [Object] the current environment.
+    def ast_env
+      @current_env
+    end
+
+    # Later invokes the block, which performs checking.
+    # The method immediately returns.
+    # This is used for avoiding infinite regression during the checking.
+    # @yield The block is later executed for checking.
+    # @return [void]
+    def check_later(&proc)
+      cur_ast = @current_ast
+      cur_env = @current_env
+      @check_list << [cur_ast, cur_env, proc]
+    end
+
+    # @private
+    def error_found!(an_ast, msg='')
+      loc  = if an_ast.is_a?(ASTnode)
+               an_ast.source_location_string
+             else
+               ''
+             end
+      @error = "#{loc} DSL #{error_group} error. #{msg}"
+      binding.pry if Yadriggy.debug > 1
+      raise CheckError.new(@error)
+    end
+
+    # @private
+    def error_group
+      ''
+    end
+
+    init_class
+  end
+end

data/lib/yadriggy/eval.rb

@@ -0,0 +1,200 @@
+# Copyright (C) 2017- Shigeru Chiba.  All rights reserved.
+
+module Yadriggy
+
+  # abstract evaluator (using visitor pattern)
+  #
+  class Eval
+    def evaluate(expr)
+      if expr.nil?
+        nil_value(nil)
+      else
+        expr.accept(self)
+      end
+      self
+    end
+
+    # A root.
+    #
+    def astree(expr)
+      evaluate(expr.tree)
+    end
+
+    def nil_value(expr)
+      raise NotImplementedError.new('nil_value')
+    end
+
+    def name(expr)
+      raise NotImplementedError.new('name')
+    end
+
+    def identifier_or_call(expr)
+      name(expr)
+    end
+
+    def identifier(expr)
+      identifier_or_call(expr)
+    end
+
+    def reserved(expr)
+      name(expr)
+    end
+
+    def const(expr)
+      name(expr)
+    end
+
+    def label(expr)
+      name(expr)
+    end
+
+    def symbol(expr)
+      raise NotImplementedError.new('symbol')
+    end
+
+    def global_variable(expr)
+      name(expr)
+    end
+
+    def instance_variable(expr)
+      name(expr)
+    end
+
+    def variable_call(expr)
+      identifier_or_call(expr)
+    end
+
+    def super_method(expr)
+      raise NotImplementedError.new('super_method')
+    end
+
+    def number(expr)
+      raise NotImplementedError.new('number')
+    end
+
+    # expressions, or progn in Lisp.
+    #
+    def exprs(expr)
+      raise NotImplementedError.new('exprs')
+    end
+
+    def paren(expr)
+      raise NotImplementedError.new('paren')
+    end
+
+    def array(expr)
+      raise NotImplementedError.new('array')
+    end
+
+    def string_interpolation(expr)
+      raise NotImplementedError.new('string_interpolation')
+    end
+
+    def string_literal(expr)
+      raise NotImplementedError.new('string_literal')
+    end
+
+    def const_path_ref(expr)
+      raise NotImplementedError.new('const_path_ref')
+    end
+
+    def const_path_field(expr)
+      const_path_ref(expr)
+    end
+
+    def unary(expr)
+      raise NotImplementedError.new('unary')
+    end
+
+    def binary(expr)
+      raise NotImplementedError.new('binary')
+    end
+
+    def dots(expr)
+      binary(expr)
+    end
+
+    def assign(expr)
+      binary(expr)
+    end
+
+    def array_ref(expr)
+      raise NotImplementedError.new('array')
+    end
+
+    def array_ref_field(expr)
+      array_ref(expr)
+    end
+
+    def hash(expr)
+      raise NotImplementedError.new('hash')
+    end
+
+    def call(expr)
+      raise NotImplementedError.new('call')
+    end
+
+    def command(expr)
+      call(expr)
+    end
+
+    def conditional(expr)
+      raise NotImplementedError.new('conditional')
+    end
+
+    def loop(expr)
+      raise NotImplementedError.new('loop')
+    end
+
+    def for_loop(expr)
+      raise NotImplementedError.new('for_loop')
+    end
+
+    def break_out(expr)
+      raise NotImplementedError.new('break_out')
+    end
+
+    def return_values(expr)
+      raise NotImplementedError.new('return_values')
+    end
+
+    def block(expr)
+      raise NotImplementedError.new('block')
+    end
+
+    def lambda_expr(expr)
+      block(expr)
+    end
+
+    def being_end(expr)
+      raise NotImplementedError.new('begin_end')
+    end
+
+    # def
+    #
+    def define(expr)
+      raise NotImplementedError.new('define')
+    end
+
+    def rescue_end(expr)
+      raise NotImplementedError.new('rescue_end')
+    end
+
+    def module_def(expr)
+      raise NotImplementedError.new('module_def')
+    end
+
+    def class_def(expr)
+      raise NotImplementedError.new('class_def')
+    end
+
+    def singular_class_def(expr)
+      raise NotImplementedError.new('singular_class_def')
+    end
+
+    def program(expr)
+      raise NotImplementedError.new('program')
+    end
+  end
+
+end