sfrp 1.1.0

data/lib/sfrp/raw/dsl.rb

@@ -0,0 +1,41 @@
+module SFRP
+  module Raw
+    extend SFRP::R = self
+
+    def r(rname, qualifier = nil)
+      Ref.new(rname, qualifier)
+    end
+
+    def t(tconst_ref, args, sp = nil)
+      TypeAnnotationType.new(tconst_ref, args, sp)
+    end
+
+    def tv(var_str, sp = nil)
+      TypeAnnotationVar.new(var_str, sp)
+    end
+
+    def ft(ret_t, arg_ts)
+      FuncTypeAnnotation.new(ret_t, arg_ts)
+    end
+
+    def v_e(var_str, sp = nil)
+      VarRefExp.new(var_str, sp)
+    end
+
+    def nr_e(node_ref, last, sp = nil)
+      NodeRefExp.new(node_ref, last, sp)
+    end
+
+    def call_e(func_ref, args, sp = nil)
+      FuncCallExp.new(func_ref, args, sp)
+    end
+
+    def vc_call_e(vconst_ref, args, sp = nil)
+      VConstCallExp.new(vconst_ref, args, sp)
+    end
+
+    def seq_e(exps, func_refs, sp = nil)
+      SequenceExp.new(exps, func_refs, sp)
+    end
+  end
+end

data/lib/sfrp/raw/elements.rb

@@ -0,0 +1,164 @@
+module SFRP
+  module Raw
+    class Function < Struct.new(:rname, :ns, :ret_ta, :pstrs, :ptas, :exp, :ffi_str, :effect, :sp)
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def vconst_refs
+        exp ? exp.vconst_refs : []
+      end
+
+      def gen_flat(src_set, dest_set)
+        exp.blame_side_effect if exp && !effect
+        flat_exp = exp && exp.to_flat(src_set, ns)
+        flat_ret_ta = ret_ta && ret_ta.to_flat(src_set, ns)
+        flat_ptas = ptas.map { |ta| ta && ta.to_flat(src_set, ns) }
+        dest_set << Flat::Function.new(
+          absolute_name, flat_ret_ta, pstrs, flat_ptas, flat_exp, ffi_str, sp
+        )
+      end
+    end
+
+    class TConst < Struct.new(:rname, :ns, :pstrs, :vconsts, :native_str, :static, :sp)
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def gen_flat(_src_set, dest_set)
+        vconst_strs = vconsts.map(&:absolute_name)
+        dest_set << Flat::TConst.new(absolute_name, pstrs, vconst_strs, native_str, static, sp)
+      end
+    end
+
+    class VConst < Struct.new(:rname, :tconst_rname, :ns, :native_str, :param_tas, :sp)
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def gen_flat(src_set, dest_set)
+        tconst_str = src_set.tconst(ns, Ref.new(tconst_rname), sp).absolute_name
+        flat_param_tas = param_tas.map { |ta| ta.to_flat(src_set, ns) }
+        dest_set << Flat::VConst.new(absolute_name, tconst_str, native_str, flat_param_tas, sp)
+      end
+    end
+
+    class PrimTConst < Struct.new(:rname, :ns, :native_str, :pat, :rep, :sp)
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def vconst_match?(vconst_str)
+        pat.match(vconst_str)
+      end
+
+      def make_vconst(vconst_str)
+        raise vconst_str unless vconst_match?(vconst_str)
+        VConst.new(vconst_str, rname, ns, vconst_str.gsub(pat, rep), [], sp)
+      end
+
+      def gen_flat(_src_set, dest_set)
+        dest_set << Flat::TConst.new(absolute_name, [], nil, native_str, true, sp)
+      end
+    end
+
+    class Init < Struct.new(:ns, :func_ref, :arg_exps, :line_number)
+      def func_rname
+        "%init#{line_number}"
+      end
+
+      def function
+        exp = FuncCallExp.new(func_ref, arg_exps, true)
+        Function.new(func_rname, ns, nil, [], [], exp, nil, true)
+      end
+
+      def gen_flat(src_set, dest_set)
+        function.gen_flat(src_set, dest_set)
+        dest_set.append_init_func_str(function.absolute_name)
+      end
+    end
+
+    class Node < Struct.new(:rname, :ns, :ta, :exp, :init_exp, :sp)
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def vconst_refs
+        [exp, init_exp].reject(&:nil?).flat_map(&:vconst_refs)
+      end
+
+      def gen_flat(src_set, dest_set)
+        exp.blame_side_effect
+        flat_ta = ta && ta.to_flat(src_set, ns)
+        flat_init_exp = init_exp && init_exp.to_flat(src_set, ns)
+        flat_exp = exp && exp.to_flat(src_set, ns)
+        dest_set << Flat::Node.new(absolute_name, flat_ta, flat_exp, flat_init_exp, sp)
+      end
+    end
+
+    class Output < Struct.new(:ns, :exps, :func_ref, :line_number, :sp)
+      def rname
+        "%output_line#{line_number}"
+      end
+
+      def absolute_name
+        ns.absolute_name(rname)
+      end
+
+      def convert
+        exp = FuncCallExp.new(func_ref, exps, false, sp)
+        ta = TypeAnnotationType.new(Ref.new('Unit'), [])
+        Node.new(rname, ns, ta, exp, nil, sp)
+      end
+    end
+
+    class Input < Struct.new(:rname, :ns, :ta, :arg_exps, :init_exp, :func_ref, :sp)
+      def convert
+        exp = FuncCallExp.new(func_ref, arg_exps, false, sp)
+        Node.new(rname, ns, ta, exp, init_exp, sp)
+      end
+    end
+
+    class Infix < Struct.new(:ns, :func_ref, :priority, :direction, :sp)
+      LEFT, RIGHT, NONE = :left, :right, :none
+
+      def absolute_func_name(set)
+        func_name = set.func(ns, func_ref, sp).absolute_name
+        raise NameError.new(func_ref.to_s, sp) unless func_name
+        func_name
+      end
+
+      def absolute_priority(position)
+        case direction
+        when LEFT
+          [priority, 1000 - position]
+        when RIGHT
+          [priority, position]
+        when NONE
+          [priority, 0]
+        end
+      end
+    end
+
+    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas, :sp)
+      def to_flat(set, ns)
+        flat_arg_tas = arg_tas.map { |ta| ta.to_flat(set, ns) }
+        Flat::FuncTypeAnnotation.new(ret_ta.to_flat(set, ns), flat_arg_tas, sp)
+      end
+    end
+
+    class TypeAnnotationType < Struct.new(:tconst_ref, :arg_tas, :sp)
+      def to_flat(set, ns)
+        ab_tc_name = set.tconst(ns, tconst_ref, sp).absolute_name
+        flat_arg_tas = arg_tas.map { |ta| ta.to_flat(set, ns) }
+        Flat::TypeAnnotationType.new(ab_tc_name, flat_arg_tas, sp)
+      end
+    end
+
+    class TypeAnnotationVar < Struct.new(:var_str, :sp)
+      def to_flat(_set, _ns)
+        Flat::TypeAnnotationVar.new(var_str, sp)
+      end
+    end
+  end
+end

data/lib/sfrp/raw/exception.rb

@@ -0,0 +1,40 @@
+require 'sfrp/error'
+
+module SFRP
+  module Raw
+    class NameError < CompileError
+      def initialize(target_str, source_position)
+        @target_str = target_str
+        @source_position = source_position
+      end
+
+      def message
+        "Cannot resolve '#{@target_str}'"
+      end
+    end
+
+    class AmbiguousNameError < CompileError
+      def initialize(target_str, selection_strs, source_position)
+        @target_str = target_str
+        @selection_strs = selection_strs
+        @source_position = source_position
+      end
+
+      def message
+        "Ambiguous name '#{@target_str}':\n" +
+        @selection_strs.map { |s| '  ' + s }.join("\n")
+      end
+    end
+
+    class IllegalSideEffectError < CompileError
+      def initialize(target_str, source_position)
+        @target_str = target_str
+        @source_position = source_position
+      end
+
+      def message
+        "Don't call side-effect function '#{@target_str}'"
+      end
+    end
+  end
+end

data/lib/sfrp/raw/expression.rb

@@ -0,0 +1,168 @@
+module SFRP
+  module Raw
+    class FuncCallExp < Struct.new(:func_ref, :arg_exps, :effect, :sp)
+      def vconst_refs
+        arg_exps.flat_map(&:vconst_refs)
+      end
+
+      def blame_side_effect
+        raise IllegalSideEffectError.new(func_ref.to_s, sp) if effect
+        arg_exps.each(&:blame_side_effect)
+      end
+
+      def to_flat(set, ns)
+        ab_func_name = set.func(ns, func_ref, sp).absolute_name
+        args = arg_exps.map { |e| e.to_flat(set, ns) }
+        Flat::FuncCallExp.new(ab_func_name, args, sp)
+      end
+    end
+
+    class VConstCallExp < Struct.new(:vconst_ref, :arg_exps, :sp)
+      def vconst_refs
+        [vconst_ref, *arg_exps.flat_map(&:vconst_refs)]
+      end
+
+      def blame_side_effect
+        arg_exps.each(&:blame_side_effect)
+      end
+
+      def to_flat(set, ns)
+        ab_vc_name = set.vconst(ns, vconst_ref, sp).absolute_name
+        args = arg_exps.map { |e| e.to_flat(set, ns) }
+        Flat::VConstCallExp.new(ab_vc_name, args, sp)
+      end
+    end
+
+    class NodeRefExp < Struct.new(:node_ref, :last, :sp)
+      def vconst_refs
+        []
+      end
+
+      def blame_side_effect
+        nil
+      end
+
+      def to_flat(set, ns)
+        ab_node_name = set.node(ns, node_ref, sp).absolute_name
+        Flat::NodeRefExp.new(ab_node_name, last)
+      end
+    end
+
+    class MatchExp < Struct.new(:left_exp, :cases, :sp)
+      Case = Struct.new(:pattern, :exp)
+
+      class Pattern < Struct.new(:vconst_ref, :ref_var_str, :args, :sp)
+        def vconst_refs
+          (vconst_ref ? [vconst_ref] : []) + args.flat_map(&:vconst_refs)
+        end
+
+        def to_flat(set, ns)
+          flat_args = args.map { |a| a.to_flat(set, ns) }
+          if vconst_ref
+            ab_vc_name = set.vconst(ns, vconst_ref, sp).absolute_name
+            Flat::MatchExp::Pattern.new(ab_vc_name, ref_var_str, flat_args, sp)
+          else
+            Flat::MatchExp::Pattern.new(nil, ref_var_str, flat_args, sp)
+          end
+        end
+      end
+
+      def vconst_refs
+        [left_exp, *cases.map(&:pattern), *cases.map(&:exp)].flat_map(&:vconst_refs)
+      end
+
+      def blame_side_effect
+        left_exp.blame_side_effect
+        cases.map(&:exp).each(&:blame_side_effect)
+      end
+
+      def to_flat(set, ns)
+        flat_cases = cases.map do |c|
+          flat_pattern = c.pattern.to_flat(set, ns)
+          Flat::MatchExp::Case.new(flat_pattern, c.exp.to_flat(set, ns))
+        end
+        Flat::MatchExp.new(left_exp.to_flat(set, ns), flat_cases, sp)
+      end
+    end
+
+    class VarRefExp < Struct.new(:var_str, :sp)
+      def vconst_refs
+        []
+      end
+
+      def blame_side_effect
+        nil
+      end
+
+      def to_flat(_set, _ns)
+        Flat::VarRefExp.new(var_str, sp)
+      end
+    end
+
+    class SequenceExp < Struct.new(:exps, :func_refs, :sp)
+      def vconst_refs
+        exps.flat_map(&:vconst_refs)
+      end
+
+      def blame_side_effect
+        exps.each { |e| e.blame_side_effect }
+      end
+
+      def convert(set, ns)
+        return exps[0] if exps.size == 1
+        pos = set.weakest_op_position(ns, func_refs, sp)
+        lseq = SequenceExp.new(exps.take(pos + 1), func_refs.take(pos), sp)
+        rseq = SequenceExp.new(exps.drop(pos + 1), func_refs.drop(pos + 1), sp)
+        args = [lseq.convert(set, ns), rseq.convert(set, ns)]
+        FuncCallExp.new(func_refs[pos], args, false, sp)
+      end
+
+      def to_flat(set, ns)
+        convert(set, ns).to_flat(set, ns)
+      end
+    end
+
+    module SugarExp
+      def vconst_refs
+        convert.vconst_refs
+      end
+
+      def blame_side_effect
+        convert.blame_side_effect
+      end
+
+      def to_flat(set, ns)
+        convert.to_flat(set, ns)
+      end
+    end
+
+    class IfExp < Struct.new(:cond_exp, :then_exp, :else_exp, :sp)
+      include SugarExp
+
+      def convert
+        cases = [
+          MatchExp::Case.new(
+            MatchExp::Pattern.new(Ref.new('True'), nil, [], sp), then_exp
+          ),
+          MatchExp::Case.new(
+            MatchExp::Pattern.new(Ref.new('False'), nil, [], sp), else_exp
+          )
+        ]
+        MatchExp.new(cond_exp, cases, sp)
+      end
+    end
+
+    class LetExp < Struct.new(:exp, :assignments, :sp)
+      include SugarExp
+
+      Assignment = Struct.new(:pattern, :exp)
+
+      def convert
+        raise if assignments.empty?
+        assignments.reverse.reduce(exp) do |e, ass|
+          MatchExp.new(ass.exp, [MatchExp::Case.new(ass.pattern, e)], sp)
+        end
+      end
+    end
+  end
+end

data/lib/sfrp/raw/namespace.rb

@@ -0,0 +1,30 @@
+module SFRP
+  module Raw
+    class Ref < Struct.new(:relative_name, :qualifier_name, :sp)
+      def to_s
+        return relative_name if qualifier_name.nil?
+        qualifier_name + '.' + relative_name
+      end
+    end
+
+    class Import < Struct.new(:absolute_namespace_name, :qualifier_name)
+
+    end
+
+    class Namespace
+      def initialize(absolute_namespace_name, imports)
+        @absolute_namespace_name = absolute_namespace_name
+        @imports = [Import.new(absolute_namespace_name, nil), *imports]
+      end
+
+      def absolute_name(relative_name)
+        @absolute_namespace_name + '.' + relative_name
+      end
+
+      def search_for_absolute_names(ref)
+        @imports.select { |i| i.qualifier_name == ref.qualifier_name }
+          .map { |i| i.absolute_namespace_name + '.' + ref.relative_name }
+      end
+    end
+  end
+end