sfrp 1.1.0

data/lib/sfrp/low/set.rb

@@ -0,0 +1,62 @@
+require 'sfrp/low/element'
+require 'sfrp/low/dsl'
+
+module SFRP
+  module Low
+    class Set
+      attr_reader :meta, :typedefs, :structs, :functions, :macros, :includes
+
+      def initialize(&block)
+        @typedefs = []
+        @structs = []
+        @functions = []
+        @macros = []
+        @includes = []
+        block.call(self) if block
+      end
+
+      def to_output
+        Output::Set.new do |dest_set|
+          dest_set.create_file('main', 'c', main_file_content)
+        end
+      end
+
+      def <<(element)
+        case element
+        when Typedef
+          @typedefs << element
+        when Structure
+          @structs << element
+        when Function
+          @functions << element
+        when Macro
+          @macros << element
+        when Include
+          @includes << element
+        else
+          raise
+        end
+      end
+
+      private
+
+      def main_file_content
+        elements = []
+        @includes.each { |x| elements << x.to_s }
+        @macros.each { |x| elements << x.to_s }
+        @typedefs.each { |x| elements << x.to_s }
+        @structs.each { |x| elements << x.to_s }
+        @functions.each do |x|
+          elements << x.pretty_code_prototype
+        end
+        @functions.each { |x| elements << x.to_s }
+        elements.join("\n")
+      end
+
+      def header_file_content
+        elements = []
+        elements.join("\n")
+      end
+    end
+  end
+end

data/lib/sfrp/mono/dsl.rb

@@ -0,0 +1,120 @@
+module SFRP
+  module Mono
+    module DSL
+      extend SFRP::M = self
+
+      def type(type_str, vconst_strs = nil, static = false, native_str = nil)
+        Type.new(type_str, vconst_strs, static, native_str)
+      end
+
+      def vconst(type_str, vconst_str, arg_type_strs, native_str = nil)
+        VConst.new(vconst_str, type_str, arg_type_strs, native_str)
+      end
+
+      def node(type_str, node_str, eval_func_str, init_func_str = nil, &block)
+        px = NodeDepProxy.new
+        block.call(px) if block
+        Node.new(node_str, type_str, px.to_a, eval_func_str, init_func_str)
+      end
+
+      def func(type_str, func_str, &block)
+        fp = FuncProxy.new
+        block.call(fp) if block
+        ftype = fp.ftype(type_str)
+        Function.new(func_str, fp.param_strs, ftype, fp.exp, fp.ffi_str)
+      end
+
+      def match_e(type_str, left_exp, &block)
+        cp = CaseProxy.new
+        block.call(cp) if block
+        MatchExp.new(type_str, left_exp, cp.to_a)
+      end
+
+      def call_e(type_str, func_str, *arg_exps)
+        FuncCallExp.new(type_str, func_str, arg_exps)
+      end
+
+      def vc_call_e(type_str, vconst_str, *arg_exps)
+        VConstCallExp.new(type_str, vconst_str, arg_exps)
+      end
+
+      def v_e(type_str, var_str)
+        VarRefExp.new(type_str, var_str)
+      end
+
+      def pat(type_str, vconst_str, *arg_patterns)
+        Pattern.new(type_str, vconst_str, nil, arg_patterns)
+      end
+
+      def pref(type_str, vconst_str, ref_var_str, *arg_patterns)
+        Pattern.new(type_str, vconst_str, ref_var_str, arg_patterns)
+      end
+
+      def pany(type_str, ref_var_str = nil)
+        Pattern.new(type_str, nil, ref_var_str, [])
+      end
+
+      class NodeDepProxy
+        def initialize
+          @node_refs = []
+        end
+
+        def l(node_str)
+          @node_refs << Node::NodeRef.new(node_str, true)
+        end
+
+        def c(node_str)
+          @node_refs << Node::NodeRef.new(node_str, false)
+        end
+
+        def to_a
+          @node_refs
+        end
+      end
+
+      class CaseProxy
+        def initialize
+          @cases = []
+        end
+
+        def case(pattern, &exp_block)
+          @cases << MatchExp::Case.new(pattern, exp_block.call)
+        end
+
+        def to_a
+          @cases
+        end
+      end
+
+      class FuncProxy
+        def initialize
+          @param_type_strs = []
+          @param_strs = []
+        end
+
+        def param(type_str, param_str)
+          @param_type_strs << type_str
+          @param_strs << param_str
+        end
+
+        def exp(&exp_block)
+          @exp = exp_block.call if exp_block
+          @exp
+        end
+
+        def ffi_str(str = nil)
+          @ffi_str = str if str
+          @ffi_str
+        end
+
+        def param_strs
+          @param_strs
+        end
+
+        def ftype(return_type_str)
+          Function::FType.new(@param_type_strs, return_type_str)
+        end
+      end
+    end
+  end
+end

data/lib/sfrp/mono/environment.rb

@@ -0,0 +1,26 @@
+module SFRP
+  module Mono
+    class Environment
+      def initialize
+        @serial_queue = ('_v00'..'_v99').to_a
+        @var_str_to_type_str = {}
+      end
+
+      def new_var(type_str)
+        var = @serial_queue.shift
+        @var_str_to_type_str[var] = type_str
+        var
+      end
+
+      def add_var(var_str, type_str)
+        @var_str_to_type_str[var_str] = type_str
+      end
+
+      def each_declared_vars(&block)
+        @var_str_to_type_str.each do |var_str, type_str|
+          block.call(var_str, type_str)
+        end
+      end
+    end
+  end
+end

data/lib/sfrp/mono/exception.rb

@@ -0,0 +1,21 @@
+require 'sfrp/error'
+
+module SFRP
+  module Mono
+    class InvalidTypeOfForeignFunctionError < CompileError
+      def initialize(ffi_str)
+        @ffi_str = ffi_str
+      end
+
+      def message
+        "foreign function '#{@ffi_str}' returns invalid type'"
+      end
+    end
+
+    class IncompleteMatchExpError < CompileError
+      def message
+        "incomplete match-exp"
+      end
+    end
+  end
+end

data/lib/sfrp/mono/expression.rb

@@ -0,0 +1,124 @@
+module SFRP
+  module Mono
+    class Exp
+      attr_reader :type_str
+
+      def ==(other)
+        comp == other.comp
+      end
+    end
+
+    class MatchExp < Exp
+      Case = Struct.new(:pattern, :exp)
+
+      def initialize(type_str, left_exp, cases, id = nil)
+        @type_str = type_str
+        @left_exp = left_exp
+        @cases = cases
+        @id = id
+      end
+
+      def comp
+        [@type_str, @left_exp, @cases]
+      end
+
+      # Note that the expression this returns is not wrapped by ().
+      def to_low(set, env)
+        check_completeness(set)
+        tmp_var_str = env.new_var(@left_exp.type_str)
+        left_let_exp = "#{tmp_var_str} = #{@left_exp.to_low(set, env)}"
+        case_exp = L.if_chain_exp do |i|
+          @cases.each do |c|
+            cond_exps = c.pattern.low_cond_exps(set, tmp_var_str)
+            let_exps = c.pattern.low_let_exps(set, tmp_var_str, env)
+            exp = (let_exps + [c.exp.to_low(set, env)]).join(', ')
+            i.finish(exp) if cond_exps.empty?
+            i.append_case(cond_exps.join(' && '), exp)
+          end
+        end
+        "#{left_let_exp}, #{case_exp}"
+      end
+
+      def check_completeness(set)
+        set.type(@left_exp.type_str).all_pattern_examples(set).each do |exam|
+          unless @cases.any? { |c| c.pattern.accept?(exam) }
+            raise IncompleteMatchExpError.new
+          end
+        end
+      end
+
+      def memory(set)
+        m = @cases.map { |c| c.exp.memory(set) }.reduce { |a, b| a.or(b) }
+        @left_exp.memory(set).and(m)
+      end
+    end
+
+    class FuncCallExp < Exp
+      def initialize(type_str, func_str, arg_exps, id = nil)
+        @type_str = type_str
+        @func_str = func_str
+        @arg_exps = arg_exps
+        @id = id
+      end
+
+      def comp
+        [@type_str, @func_str, @arg_exps]
+      end
+
+      def to_low(set, env)
+        low_arg_exps = @arg_exps.map { |e| e.to_low(set, env) }
+        set.func(@func_str).low_call_exp_in_exp(set, env, low_arg_exps)
+      end
+
+      def memory(set)
+        @arg_exps.reduce(set.func(@func_str).memory(set)) do |m, e|
+          m.and(e.memory(set))
+        end
+      end
+    end
+
+    class VConstCallExp < Exp
+      def initialize(type_str, vconst_str, arg_exps, id = nil)
+        @type_str = type_str
+        @vconst_str = vconst_str
+        @arg_exps = arg_exps
+        @id = id
+      end
+
+      def comp
+        [@type_str, @vconst_strs, @arg_exps]
+      end
+
+      def to_low(set, env)
+        low_arg_exps = @arg_exps.map { |e| e.to_low(set, env) }
+        set.vconst(@vconst_str).low_constructor_call_exp(low_arg_exps)
+      end
+
+      def memory(set)
+        @arg_exps.reduce(Memory.one(@type_str)) do |m, e|
+          m.and(e.memory(set))
+        end
+      end
+    end
+
+    class VarRefExp < Exp
+      def initialize(type_str, var_str, id = nil)
+        @type_str = type_str
+        @var_str = var_str
+        @id = id
+      end
+
+      def comp
+        [@type_str, @var_str]
+      end
+
+      def to_low(_set, _env)
+        @var_str
+      end
+
+      def memory(_set)
+        Memory.empty
+      end
+    end
+  end
+end

data/lib/sfrp/mono/function.rb

@@ -0,0 +1,86 @@
+require 'sfrp/mono/exception'
+
+module SFRP
+  module Mono
+    class Function
+      FType = Struct.new(:param_type_strs, :return_type_str)
+
+      attr_reader :str
+
+      def initialize(str, param_strs, ftype, exp = nil, ffi_str = nil)
+        raise ArgumentError if exp.nil? && ffi_str.nil?
+        raise ArgumentError unless param_strs.size == ftype.param_type_strs.size
+        @str = str
+        @param_strs = param_strs
+        @ftype = ftype
+        @exp = exp
+        @ffi_str = ffi_str
+      end
+
+      def comp
+        [@str, @param_strs, @ftype, @exp, @ffi_str]
+      end
+
+      def ==(other)
+        comp == other.comp
+      end
+
+      # Return max needed memory size to call this function once.
+      # If this func is a foreign function, this size is assumed as max needed
+      # memory size to hold return-type.
+      def memory(set)
+        return set.type(@ftype.return_type_str).memory(set) if @ffi_str
+        @exp.memory(set)
+      end
+
+      # Return low-expression to call this function.
+      def low_call_exp(low_arg_exps)
+        return L.call_exp(@ffi_str, low_arg_exps) if @ffi_str
+        L.call_exp(@str, low_arg_exps)
+      end
+
+      def low_call_exp_in_exp(set, env, low_arg_exps)
+        if @ffi_str
+          type = set.type(@ftype.return_type_str)
+          if @ffi_str !~ /[a-zA-Z]/
+            if low_arg_exps.size == 2
+              return "(#{low_arg_exps[0]}) #{@ffi_str} (#{low_arg_exps[1]})"
+            end
+            if low_arg_exps.size == 1
+              return "#{@ffi_str} (#{low_arg_exps[0]})"
+            end
+            raise InvalidTypeOfForeignFunctionError.new(@ffi_str)
+          end
+          if type.native?
+            return L.call_exp(@ffi_str, low_arg_exps)
+          end
+          if type.linear?(set)
+            var = env.new_var(@ftype.return_type_str)
+            pointers = type.low_member_pointers_for_single_vconst(set, var)
+            call_exp = L.call_exp(@ffi_str, low_arg_exps + pointers)
+            return "(#{var} = #{type.low_allocator_str}(0), #{call_exp}, #{var})"
+          end
+          raise InvalidTypeOfForeignFunctionError.new(@ffi_str)
+        end
+        L.call_exp(@str, low_arg_exps)
+      end
+
+      # Generate function in C for this function.
+      def gen(src_set, dest_set)
+        return if @ffi_str
+        env = Environment.new
+        type = src_set.type(@ftype.return_type_str)
+        dest_set << L.function(@str, type.low_type_str) do |f|
+          @param_strs.zip(@ftype.param_type_strs).map do |p_str, t_str|
+            f.append_param(src_set.type(t_str).low_type_str, p_str)
+          end
+          stmt = L.stmt("return #{@exp.to_low(src_set, env)}")
+          env.each_declared_vars do |var_str, type_str|
+            f << L.stmt("#{src_set.type(type_str).low_type_str} #{var_str}")
+          end
+          f << stmt
+        end
+      end
+    end
+  end
+end

data/lib/sfrp/mono/memory.rb

@@ -0,0 +1,32 @@
+module SFRP
+  module Mono
+    class Memory
+      def self.empty
+        Memory.new
+      end
+
+      def self.one(type_str)
+        Memory.new(type_str => 1)
+      end
+
+      def initialize(hash = {})
+        @hash = hash
+      end
+
+      def and(other)
+        Memory.new(@hash.merge(other.hash) { |_, v1, v2| v1 + v2 })
+      end
+
+      def or(other)
+        Memory.new(@hash.merge(other.hash) { |_, v1, v2| [v1, v2].max })
+      end
+
+      def count(type_str)
+        @hash[type_str] || 0
+      end
+
+      protected
+      attr_reader :hash
+    end
+  end
+end