sfrp 1.1.0

data/lib/sfrp/raw/set.rb

@@ -0,0 +1,109 @@
+require 'sfrp/raw/elements'
+require 'sfrp/raw/exception'
+require 'sfrp/raw/expression'
+require 'sfrp/raw/namespace'
+require 'sfrp/raw/dsl'
+
+module SFRP
+  module Raw
+    class Set
+      def initialize(&block)
+        @infixies = []
+        @inits = []
+        @prim_tconsts = []
+        @output_node_strs = []
+        @vconst_h = {}
+        @func_h = {}
+        @tconst_h = {}
+        @node_h = {}
+        block.call(self) if block
+        vconst_refs.each { |vr| append_literal_vconst(vr.relative_name) }
+      end
+
+      def to_flat
+        Flat::Set.new do |dest_set|
+          [
+            @func_h, @tconst_h, @vconst_h, @node_h
+          ].flat_map(&:values).each { |e| e.gen_flat(self, dest_set) }
+          @inits.each { |i| i.gen_flat(self, dest_set) }
+          @output_node_strs.each { |s| dest_set.append_output_node_str(s) }
+        end
+      end
+
+      def <<(element)
+        case element
+        when Function
+          @func_h[element.absolute_name] = element
+        when TConst
+          @tconst_h[element.absolute_name] = element
+          element.vconsts.each { |v| @vconst_h[v.absolute_name] = v }
+        when PrimTConst
+          @tconst_h[element.absolute_name] = element
+          @prim_tconsts << element
+        when Node
+          @node_h[element.absolute_name] = element
+        when Output
+          self << element.convert
+          @output_node_strs << element.absolute_name
+        when Input
+          self << element.convert
+        when Infix
+          @infixies << element
+        when Init
+          @inits << element
+        else
+          raise
+        end
+      end
+
+      def weakest_op_position(ns, func_refs, sp)
+        ab_func_names = func_refs.map { |fr| func(ns, fr, sp).absolute_name }
+        infix_h = Hash[@infixies.map { |i| [i.absolute_func_name(self), i] }]
+        ab_func_names.each_with_index.map do |x, idx|
+          [(infix_h.key?(x) ? infix_h[x].absolute_priority(idx) : [0, 0]), idx]
+        end.min[1]
+      end
+
+      def func(ns, func_ref, sp)
+        resolve(ns, func_ref, @func_h, sp)
+      end
+
+      def vconst(ns, vconst_ref, sp)
+        resolve(ns, vconst_ref, @vconst_h, sp)
+      end
+
+      def node(ns, node_ref, sp)
+        resolve(ns, node_ref, @node_h, sp)
+      end
+
+      def tconst(ns, tconst_ref, sp)
+        resolve(ns, tconst_ref, @tconst_h, sp)
+      end
+
+      private
+
+      def resolve(ns, ref, hash, sp)
+        hits = ns.search_for_absolute_names(ref).select { |x| hash.key?(x) }
+        raise NameError.new(ref.to_s, sp) if hits.empty?
+        raise AmbiguousNameError.new(ref.to_s, hits, sp) if hits.size > 1
+        hash[hits[0]]
+      end
+
+      def vconst_refs
+        elements = [@func_h, @node_h].flat_map(&:values)
+        elements.flat_map(&:vconst_refs)
+      end
+
+      def append_literal_vconst(str)
+        return unless str =~ /^[0-9].*/
+        @prim_tconsts.each do |prim_tconst|
+          next unless prim_tconst.vconst_match?(str)
+          new_vconst = prim_tconst.make_vconst(str)
+          unless @vconst_h.key?(new_vconst.absolute_name)
+            @vconst_h[new_vconst.absolute_name] = new_vconst
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sfrp/version.rb

@@ -0,0 +1,3 @@
+module SFRP
+  VERSION = '1.1.0'
+end

data/sfrp.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sfrp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sfrp"
+  spec.version       = SFRP::VERSION
+  spec.authors       = ["Kensuke Sawada"]
+  spec.email         = ["sasasawada@gmail.com"]
+  spec.summary       =
+    %q{Compiler of a pure functional language for microcontrollers.}
+  spec.description   = %q{Pure Functional Language for microcontrollers.}
+  spec.homepage      = "https://github.com/sfrp/sfrp"
+  spec.license       = "The BSD 3-Clause License"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  # testing
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+
+  # code analyzing
+  spec.add_development_dependency 'rubocop', '0.40.0'
+
+  # debugging
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'tapp'
+  spec.add_development_dependency 'awesome_print'
+
+  # parsing
+  spec.add_dependency "parslet", "1.7.1"
+end

data/spec/sfrp/Test.sfrp

@@ -0,0 +1,4 @@
+type Unit = Unit
+$nop(x) = Unit
+@unit(Unit) = @@unit
+out $nop(@unit)

data/spec/sfrp/compiler_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'sfrp/compiler'
+
+module SFRP
+  describe 'Compiler' do
+    let(:compiler) do
+      Compiler.new('Test', [File.dirname(__FILE__)])
+    end
+
+    it 'compiles .sfrp to .c' do
+      Dir.mktmpdir do |dirpath|
+        compiler.compile(dirpath)
+        # puts out = File.read(dirpath + '/main.c')
+      end
+    end
+  end
+end

data/spec/sfrp/flat/set_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'sfrp/flat/set'
+require 'sfrp/poly/set'
+
+module SFRP
+  describe 'Compiled Poly-Set from Flat-Set' do
+    let(:pset) do
+      Flat::Set.new do |s|
+
+        s << begin
+          exp = F.nr_e('b', false)
+          init_exp = F.call_e('init', [])
+          Flat::Node.new('a', F.tv('a'), exp, init_exp)
+        end
+
+        s << begin
+          exp = F.call_e('ff', [])
+          Flat::Node.new('b', F.tv('a'), exp, nil)
+        end
+
+        s << begin
+          int = F.t('Int', [])
+          exp = F.vc_call_e('1', [])
+          Flat::Function.new('init', int, [], [], exp, nil)
+        end
+
+        s << begin
+          int = F.t('Int', [])
+          Flat::Function.new('ff', int, [], [], nil, 'ff')
+        end
+
+        s.append_output_node_str('a')
+      end.to_poly
+    end
+
+    it 'is compiled correctly' do
+      pset # TODO wirte assertion
+    end
+  end
+end

data/spec/sfrp/input/parse_test.sfrp

@@ -0,0 +1,20 @@
+import Somewhere.Something as X
+
+ptype Int{int} = /^([0-9]+)$/\1/
+ptype Bool{int} = True{1} | False{0}
+type Maybe[a] = Just(a) | Nothing
+
+foreign + as +(Int, Int):Int
+infixl + 7
+
+foreign - as '-(Int) : Int
+
+init PIC.$init(0, 1)
+
+f(x, y) = let t = (p, p) where p = (x, y)
+              i = 100
+          in (t, i)
+
+in @pin False from $pin(0)
+@acc 0 = @@acc + - - 1
+out $world(@pin, @acc)

data/spec/sfrp/input/set_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'sfrp/input/set'
+require 'sfrp/raw/set'
+
+module SFRP
+  describe 'Compiled Raw-Set from Input-Set' do
+    let(:test_program) do
+      File.open(File.expand_path('../parse_test.sfrp', __FILE__), 'r', &:read)
+    end
+    let(:parser) do
+      Input::Parser::Parser.new
+    end
+
+    it 'is valid' do
+      expect(parser).to parse(test_program)
+    end
+  end
+end

data/spec/sfrp/low/set_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'sfrp/low/set'
+require 'sfrp/output/set'
+
+module SFRP
+  describe 'Compiled Output-Set from Low-Set' do
+    let(:oset) do
+      set = Low::Set.new do |s|
+        s << L.include_ab('hoge.h')
+      end
+      set.to_output
+    end
+
+    it 'has virtual_files' do
+      expect(oset.virtual_files).to contain_exactly(
+        VirtualFile.new('main', 'c', '#include <hoge.h>'),
+      )
+    end
+  end
+end

data/spec/sfrp/mono/expected.yml

@@ -0,0 +1,295 @@
+includes: []
+
+macros: []
+
+typedefs:
+  - typedef struct MaybeInt* MaybeInt;
+  - typedef struct Pair* Pair;
+  - typedef struct X* X;
+  - typedef struct XX* XX;
+  - typedef struct STupleIntInt STupleIntInt;
+
+structs:
+  - >
+    struct MaybeInt {
+      struct {
+        unsigned char term_id : 7;
+        unsigned char mark : 1;
+      } meta;
+      union {
+        struct {
+          int member0;
+        } term0;
+        struct {
+        } term1;
+      } terms;
+    };
+
+  - >
+    struct Pair {
+      struct {
+        unsigned char term_id : 7;
+        unsigned char mark : 1;
+      } meta;
+      union {
+        struct {
+          int member0;
+          int member1;
+        } term0;
+      } terms;
+    };
+
+  - >
+    struct X {
+      struct {
+        unsigned char term_id : 7;
+        unsigned char mark : 1;
+      } meta;
+      union {
+        struct {
+          MaybeInt member0;
+        } term0;
+        struct {
+          MaybeInt member0;
+          MaybeInt member1;
+        } term1;
+      } terms;
+    };
+
+  - >
+    struct XX {
+      struct {
+        unsigned char term_id : 7;
+        unsigned char mark : 1;
+      } meta;
+      union {
+        struct {
+          MaybeInt member0;
+        } term0;
+      } terms;
+    };
+
+  - >
+    struct STupleIntInt {
+      union {
+        struct {
+          int member0;
+          int member1;
+        } term0;
+      } terms;
+    };
+
+proto_functions:
+  - int id(int);
+  - MaybeInt initialMaybeInt();
+  - Pair toPair(MaybeInt);
+  - X swap(X);
+  - MaybeInt VC_JustInt(int);
+  - MaybeInt VC_NothingInt();
+  - MaybeInt alloc_MaybeInt(int);
+  - int mark_MaybeInt(MaybeInt);
+  - Pair VC_Pair(int, int);
+  - Pair alloc_Pair(int);
+  - int mark_Pair(Pair);
+  - X VC_X1(MaybeInt);
+  - X VC_X2(MaybeInt, MaybeInt);
+  - X alloc_X(int);
+  - int mark_X(X);
+  - XX VC_XX(MaybeInt);
+  - XX alloc_XX(int);
+  - int mark_XX(XX);
+  - STupleIntInt VC_STupleIntInt(int, int);
+  - int main();
+
+functions:
+  # Normal functions
+  - >
+    int id(int x) {
+      return x;
+    }
+
+  - >
+    MaybeInt initialMaybeInt() {
+      return VC_JustInt(1);
+    }
+
+  - >
+    Pair toPair(MaybeInt arg) {
+      MaybeInt _v00;
+      int x;
+      MaybeInt hoge;
+      Pair _v01;
+      return _v00 = arg, (_v00->meta.term_id == 0) ? (x = (_v00->terms.term0.member0), VC_Pair(x, x)) : (_v00->meta.term_id == 1) ? (hoge = (_v00), VC_Pair(id((0)), id((0)))) : ((_v01 = alloc_Pair(0), ffi_pair((&_v01->terms.term0.member0), (&_v01->terms.term0.member1)), _v01));
+    }
+
+  - >
+    X swap(X arg) {
+      X _v00;
+      MaybeInt x;
+      MaybeInt y;
+      return _v00 = arg, (_v00->meta.term_id == 0) ? (x = (_v00->terms.term0.member0), VC_X1(x)) : (x = (_v00->terms.term1.member0), y = (_v00->terms.term1.member1), VC_X2(y, x));
+    }
+
+  # Type MaybeInt
+  - >
+    MaybeInt VC_JustInt(int member0) {
+      MaybeInt x = alloc_MaybeInt(0);
+      x->meta.term_id = 0;
+      x->terms.term0.member0 = member0;
+      return x;
+    }
+
+  - >
+    MaybeInt VC_NothingInt() {
+      MaybeInt x = alloc_MaybeInt(0);
+      x->meta.term_id = 1;
+      return x;
+    }
+
+  - >
+    MaybeInt alloc_MaybeInt(int clean_up) {
+      static int i = 0;
+      static struct MaybeInt memory_MaybeInt[2];
+      if (clean_up) {
+        for (i = 0; i < 2; i++) memory_MaybeInt[i].meta.mark = 0;
+        i = 0;
+        return 0;
+      }
+      while (memory_MaybeInt[i++].meta.mark);
+      return memory_MaybeInt + (i - 1);
+    }
+
+  - >
+    int mark_MaybeInt(MaybeInt target) {
+      target->meta.mark = 1;
+      return 0;
+    }
+
+  # Type Pair
+  - >
+    Pair VC_Pair(int member0, int member1) {
+      Pair x = alloc_Pair(0);
+      x->meta.term_id = 0;
+      x->terms.term0.member0 = member0;
+      x->terms.term0.member1 = member1;
+      return x;
+    }
+
+  - >
+    Pair alloc_Pair(int clean_up) {
+      static int i = 0;
+      static struct Pair memory_Pair[1];
+      if (clean_up) {
+        for (i = 0; i < 1; i++) memory_Pair[i].meta.mark = 0;
+        i = 0;
+        return 0;
+      }
+      while (memory_Pair[i++].meta.mark);
+      return memory_Pair + (i - 1);
+    }
+
+  - >
+    int mark_Pair(Pair target) {
+      target->meta.mark = 1;
+      return 0;
+    }
+
+  # Type X
+  - >
+    X VC_X1(MaybeInt member0) {
+      X x = alloc_X(0);
+      x->meta.term_id = 0;
+      x->terms.term0.member0 = member0;
+      return x;
+    }
+
+  - >
+    X VC_X2(MaybeInt member0, MaybeInt member1) {
+      X x = alloc_X(0);
+      x->meta.term_id = 1;
+      x->terms.term1.member0 = member0;
+      x->terms.term1.member1 = member1;
+      return x;
+    }
+
+  - >
+    X alloc_X(int clean_up) {
+      static int i = 0;
+      static struct X memory_X[0];
+      if (clean_up) {
+        for (i = 0; i < 0; i++) memory_X[i].meta.mark = 0;
+        i = 0;
+        return 0;
+      }
+      while (memory_X[i++].meta.mark);
+      return memory_X + (i - 1);
+    }
+
+  - >
+    int mark_X(X target) {
+      target->meta.mark = 1;
+      if (target->meta.term_id == 0) {
+        mark_MaybeInt(target->terms.term0.member0);
+      }
+      if (target->meta.term_id == 1) {
+        mark_MaybeInt(target->terms.term1.member0), mark_MaybeInt(target->terms.term1.member1);
+      }
+      return 0;
+    }
+
+  # Type XX
+  - >
+    XX VC_XX(MaybeInt member0) {
+      XX x = alloc_XX(0);
+      x->meta.term_id = 0;
+      x->terms.term0.member0 = member0;
+      return x;
+    }
+
+  - >
+    XX alloc_XX(int clean_up) {
+      static int i = 0;
+      static struct XX memory_XX[0];
+      if (clean_up) {
+        for (i = 0; i < 0; i++) memory_XX[i].meta.mark = 0;
+        i = 0;
+        return 0;
+      }
+      while (memory_XX[i++].meta.mark);
+      return memory_XX + (i - 1);
+    }
+
+  - >
+    int mark_XX(XX target) {
+      target->meta.mark = 1;
+      mark_MaybeInt(target->terms.term0.member0);
+      return 0;
+    }
+
+  # Type STupleIntInt
+  - >
+    STupleIntInt VC_STupleIntInt(int member0, int member1) {
+      STupleIntInt x;
+      x.terms.term0.member0 = member0;
+      x.terms.term0.member1 = member1;
+      return x;
+    }
+
+  # Main functions
+  - >
+    int main() {
+      int c = 0, l = 1;
+      MaybeInt bufNode[2];
+      Pair node1[1];
+      init_system();
+      bufNode[l] = initialMaybeInt();
+      while (1) {
+        alloc_MaybeInt(1);
+        alloc_Pair(1);
+        mark_MaybeInt(bufNode[l]);
+        bufNode[c] = get_maybe_int();
+        node1[0] = toPair((bufNode[c]), (bufNode[l]));
+        c ^= 1, l ^= 1;
+      }
+      return 0;
+    }