sfrp 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8a2b6d7ba628032ad44048b3b99c9c2c8b9f0ad
-  data.tar.gz: 4d02328743284353e0858ff153764c4bb299dbf9
+  metadata.gz: cda721742189d74dac30ae37d3d0ec59d4b97085
+  data.tar.gz: 2a9ebf80928a7718b4241d5718f6f8d5fa1e035b
 SHA512:
-  metadata.gz: 5fae12fd32c4a1b97ad57d759e49e08fdf60c29b0ce0bc831e921ff02cafd0850c7b395f0c373e9bb3ac6736fa6d3ebbfb47ea4b5abe84a53c6dee522ef0fbf8
-  data.tar.gz: 697d4d030cb46f28f5146aeccd5cf5e09310ec77905c6180c0403eff50426a97c2a1ef547050d3b7abecb40940fe639c26e8ce9bf8e9346d58390b3cd4bd3e62
+  metadata.gz: ead9d2c66049bd7bf9debe408f39ccaa4c7e842096c830274ac7c3ced18f4ee426f0522b845d3394eaba2023e5cebf18b3066b7a3dc9bf2de62779c45f8718cc
+  data.tar.gz: d658239d964311003df0fa64798981d0cb9dbcd75dfc63cdc8599fc6bef846707e8c9c5f4629d15753ed6d1654856944f22d257b9e9838abcffb7ae43191be69

data/README.md

@@ -19,12 +19,12 @@ Write following simple accumulator program.
 ```
 -- Main.sfrp
 import Base
-import IO.STDIO as IO
+import Base.STDIO as IO
 
 in @x from IO.$getInt()
 out IO.$putInt(@y)
 
-@y 0 = @x + @@y
+@y init 0 = @x + @@y
 ```
 
 Compile and Run the program.

data/base-library/Base.sfrp

@@ -13,6 +13,9 @@ type Tuple5[a, b, c, d, e] = Tuple5(a, b, c, d, e)
 fst(pair : (a, b)) : a = x where (x, _) = pair
 snd(pair : (a, b)) : b = y where (_, y) = pair
 
+infixl <> 0
+op <>(a : Unit, b : Unit) : Unit = Unit
+
 foreign - as '-(Int) : Int
 foreign + as '+(Int) : Int
 foreign ! as '!(Bool) : Bool

data/base-library/Base/AVR/ATMEGA8/GPIO.c

@@ -0,0 +1,79 @@
+#include <avr/io.h>
+
+int debouncing(unsigned char count[], int pin_val, int num) {
+  if (pin_val) {
+    switch (count[num]) {
+    case 2:
+      count[num] = 1;
+      return 1;
+    case 1:
+      break;
+    case 0:
+      count[num] = 10;
+      break;
+    default:
+      count[num]--;
+    }
+  } else {
+    count[num] = 0;
+  }
+  return 0;
+}
+
+
+// PB
+
+int pinB(int num) {
+  DDRB &= ~(1 << num);
+  return (PINB & (1 << num)) == 0 ? 0 : 1;
+}
+
+int posEdgePB(int num) {
+  static unsigned char count[8];
+  return debouncing(count, pinB(num), num);
+}
+
+int portB(int port_num, int high_or_low) {
+  high_or_low = (high_or_low == 0 ? 0 : 1);
+  DDRB |= 1 << port_num;
+  PORTB = (~(1 << port_num) & PORTB) | (high_or_low << port_num);
+  return 0;
+}
+
+// PC
+
+int pinC(int num) {
+  DDRC &= ~(1 << num);
+  return (PINC & (1 << num)) == 0 ? 0 : 1;
+}
+
+int posEdgePC(int num) {
+  static unsigned char count[8];
+  return debouncing(count, pinC(num), num);
+}
+
+int portC(int port_num, int high_or_low) {
+  high_or_low = (high_or_low == 0 ? 0 : 1);
+  DDRC |= 1 << port_num;
+  PORTC = (~(1 << port_num) & PORTC) | (high_or_low << port_num);
+  return 0;
+}
+
+// PD
+
+int pinD(int num) {
+  DDRD &= ~(1 << num);
+  return (PIND & (1 << num)) == 0 ? 0 : 1;
+}
+
+int posEdgePD(int num) {
+  static unsigned char count[8];
+  return debouncing(count, pinD(num), num);
+}
+
+int portD(int port_num, int high_or_low) {
+  high_or_low = (high_or_low == 0 ? 0 : 1);
+  DDRD |= 1 << port_num;
+  PORTD = (~(1 << port_num) & PORTD) | (high_or_low << port_num);
+  return 0;
+}

data/base-library/Base/AVR/ATMEGA8/GPIO.h

@@ -0,0 +1,15 @@
+#ifndef IO_AVR_ATMEGA8_GPIO
+#define IO_AVR_ATMEGA8_GPIO
+
+// PB
+int pinB(int);
+int posEdgePB(int);
+int portB(int, int);
+
+// PC
+int portC(int, int);
+
+// PD
+int portD(int, int);
+
+#endif

data/base-library/Base/AVR/ATMEGA8/GPIO.sfrp

@@ -0,0 +1,73 @@
+import Base
+
+-- PB
+
+foreign pinB as $pinB(Int) : Bool
+in @pinB0 from $pinB(0)
+in @pinB1 from $pinB(1)
+in @pinB2 from $pinB(2)
+in @pinB3 from $pinB(3)
+in @pinB4 from $pinB(4)
+in @pinB5 from $pinB(5)
+in @pinB6 from $pinB(6)
+in @pinB7 from $pinB(7)
+
+foreign posEdgePB as $posEdgePB(Int) : Bool
+in @posEdgePB0 from $posEdgePB(0)
+in @posEdgePB1 from $posEdgePB(1)
+in @posEdgePB2 from $posEdgePB(2)
+in @posEdgePB3 from $posEdgePB(3)
+in @posEdgePB4 from $posEdgePB(4)
+in @posEdgePB5 from $posEdgePB(5)
+in @posEdgePB6 from $posEdgePB(6)
+in @posEdgePB7 from $posEdgePB(7)
+
+foreign portB as $portB(Int, Bool) : Unit
+
+-- PC
+
+foreign pinC as $pinC(Int) : Bool
+in @pinC0 from $pinC(0)
+in @pinC1 from $pinC(1)
+in @pinC2 from $pinC(2)
+in @pinC3 from $pinC(3)
+in @pinC4 from $pinC(4)
+in @pinC5 from $pinC(5)
+in @pinC6 from $pinC(6)
+in @pinC7 from $pinC(7)
+
+foreign posEdgePC as $posEdgePC(Int) : Bool
+in @posEdgePC0 from $posEdgePC(0)
+in @posEdgePC1 from $posEdgePC(1)
+in @posEdgePC2 from $posEdgePC(2)
+in @posEdgePC3 from $posEdgePC(3)
+in @posEdgePC4 from $posEdgePC(4)
+in @posEdgePC5 from $posEdgePC(5)
+in @posEdgePC6 from $posEdgePC(6)
+in @posEdgePC7 from $posEdgePC(7)
+
+foreign portC as $portC(Int, Bool) : Unit
+
+-- PD
+
+foreign pinD as $pinD(Int) : Bool
+in @pinD0 from $pinD(0)
+in @pinD1 from $pinD(1)
+in @pinD2 from $pinD(2)
+in @pinD3 from $pinD(3)
+in @pinD4 from $pinD(4)
+in @pinD5 from $pinD(5)
+in @pinD6 from $pinD(6)
+in @pinD7 from $pinD(7)
+
+foreign posEdgePD as $posEdgePD(Int) : Bool
+in @posEdgePD0 from $posEdgePD(0)
+in @posEdgePD1 from $posEdgePD(1)
+in @posEdgePD2 from $posEdgePD(2)
+in @posEdgePD3 from $posEdgePD(3)
+in @posEdgePD4 from $posEdgePD(4)
+in @posEdgePD5 from $posEdgePD(5)
+in @posEdgePD6 from $posEdgePD(6)
+in @posEdgePD7 from $posEdgePD(7)
+
+foreign portD as $portD(Int, Bool) : Unit

data/lib/sfrp/flat/dsl.rb

@@ -2,32 +2,32 @@ module SFRP
   module Flat
     extend SFRP::F = self
 
-    def t(tconst_str, args, sp = nil)
-      TypeAnnotationType.new(tconst_str, args, sp)
+    def t(tconst_str, args)
+      TypeAnnotationType.new(tconst_str, args)
     end
 
-    def tv(var_str, sp = nil)
-      TypeAnnotationVar.new(var_str, sp)
+    def tv(var_str)
+      TypeAnnotationVar.new(var_str)
     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)
+    def v_e(var_str)
+      VarRefExp.new(var_str)
     end
 
-    def nr_e(node_str, last, sp = nil)
-      NodeRefExp.new(node_str, last, sp)
+    def nr_e(node_str, last)
+      NodeRefExp.new(node_str, last)
     end
 
-    def call_e(func_str, args, sp = nil)
-      FuncCallExp.new(func_str, args, sp)
+    def call_e(func_str, args)
+      FuncCallExp.new(func_str, args)
     end
 
-    def vc_call_e(vconst_str, args, sp = nil)
-      VConstCallExp.new(vconst_str, args, sp)
+    def vc_call_e(vconst_str, args)
+      VConstCallExp.new(vconst_str, args)
     end
   end
 end

data/lib/sfrp/flat/elements.rb

@@ -1,6 +1,6 @@
 module SFRP
   module Flat
-    class Function < Struct.new(:str, :ret_ta, :pstrs, :ptas, :exp, :ffi_str, :sp)
+    class Function < Struct.new(:str, :ret_ta, :pstrs, :ptas, :exp, :ffi_str)
       def to_poly(_src_set, dest_set)
         pstrs.reject(&:nil?).each do |s|
           raise DuplicatedVariableError.new(s) if pstrs.count(s) > 1
@@ -20,7 +20,7 @@ module SFRP
       end
     end
 
-    class TConst < Struct.new(:str, :pstrs, :vc_strs, :native_str, :static, :sp)
+    class TConst < Struct.new(:str, :pstrs, :vc_strs, :native_str, :static)
       def type_annot
         TypeAnnotationType.new(str, pstrs.map { |s| TypeAnnotationVar.new(s) })
       end
@@ -31,7 +31,7 @@ module SFRP
       end
     end
 
-    class VConst < Struct.new(:str, :tconst_str, :native_str, :param_tas, :sp)
+    class VConst < Struct.new(:str, :tconst_str, :native_str, :param_tas)
       def to_poly(src_set, dest_set)
         tconst = src_set.tconst(tconst_str)
         fta = FuncTypeAnnotation.new(tconst.type_annot, param_tas)
@@ -39,7 +39,7 @@ module SFRP
       end
     end
 
-    class Node < Struct.new(:str, :ta, :exp, :init_exp, :sp)
+    class Node < Struct.new(:str, :ta, :exp, :init_exp)
       def initialized?
         !init_exp.nil?
       end
@@ -69,19 +69,19 @@ module SFRP
       end
     end
 
-    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas, :sp)
+    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas)
       def to_poly
         Poly::FuncTypeAnnotation.new(ret_ta.to_poly, arg_tas.map(&:to_poly))
       end
     end
 
-    class TypeAnnotationType < Struct.new(:tconst_str, :arg_tas, :sp)
+    class TypeAnnotationType < Struct.new(:tconst_str, :arg_tas)
       def to_poly
         P.t(tconst_str, *arg_tas.map(&:to_poly))
       end
     end
 
-    class TypeAnnotationVar < Struct.new(:var_str, :sp)
+    class TypeAnnotationVar < Struct.new(:var_str)
       def to_poly
         P.tv(var_str)
       end

data/lib/sfrp/flat/expression.rb

@@ -1,9 +1,9 @@
 module SFRP
   module Flat
-    class FuncCallExp < Struct.new(:func_str, :arg_exps, :sp)
+    class FuncCallExp < Struct.new(:func_str, :arg_exps)
       def lift_node_ref(collected_node_refs)
         args = arg_exps.map { |e| e.lift_node_ref(collected_node_refs) }
-        FuncCallExp.new(func_str, args, sp)
+        FuncCallExp.new(func_str, args)
       end
 
       def alpha_convert(table, serial)
@@ -16,10 +16,10 @@ module SFRP
       end
     end
 
-    class VConstCallExp < Struct.new(:vconst_str, :arg_exps, :sp)
+    class VConstCallExp < Struct.new(:vconst_str, :arg_exps)
       def lift_node_ref(collected_node_refs)
         args = arg_exps.map { |e| e.lift_node_ref(collected_node_refs) }
-        VConstCallExp.new(vconst_str, args, sp)
+        VConstCallExp.new(vconst_str, args)
       end
 
       def alpha_convert(table, serial)
@@ -32,7 +32,7 @@ module SFRP
       end
     end
 
-    class NodeRefExp < Struct.new(:node_str, :last, :sp)
+    class NodeRefExp < Struct.new(:node_str, :last)
       NodeRef = Struct.new(:node_str, :last)
 
       def lift_node_ref(collected_node_refs)
@@ -40,7 +40,7 @@ module SFRP
         unless collected_node_refs.include?(node_ref)
           collected_node_refs << node_ref
         end
-        VarRefExp.new("__node_ref_#{collected_node_refs.index(node_ref)}", sp)
+        VarRefExp.new("__node_ref_#{collected_node_refs.index(node_ref)}")
       end
 
       def alpha_convert(_table, _serial)
@@ -52,10 +52,10 @@ module SFRP
       end
     end
 
-    class MatchExp < Struct.new(:left_exp, :cases, :sp)
+    class MatchExp < Struct.new(:left_exp, :cases)
       Case = Struct.new(:pattern, :exp)
 
-      class Pattern < Struct.new(:vconst_str, :ref_var_str, :args, :sp)
+      class Pattern < Struct.new(:vconst_str, :ref_var_str, :args)
         def alpha_convert(table, serial)
           new_ref_var_str =
             ref_var_str && (table[ref_var_str] = "_alpha#{serial.shift}")
@@ -84,7 +84,7 @@ module SFRP
         new_cases = cases.map do |c|
           Case.new(c.pattern, c.exp.lift_node_ref(collected_node_refs))
         end
-        MatchExp.new(new_left_exp, new_cases, sp)
+        MatchExp.new(new_left_exp, new_cases)
       end
 
       def alpha_convert(table, serial)
@@ -107,7 +107,7 @@ module SFRP
       end
     end
 
-    class VarRefExp < Struct.new(:var_str, :sp)
+    class VarRefExp < Struct.new(:var_str)
       def lift_node_ref(_collected_node_refs)
         self
       end

data/lib/sfrp/input/parser.rb

@@ -132,7 +132,7 @@ module SFRP
           ws? >> str(')')).as(:output_def)
         }
         rule(:init_def_maybe) {
-          (ws? >> exp.as(:init_exp)).maybe.as(:init_def_maybe)
+          (ws? >> str('init') >> ws >> exp.as(:init_exp)).maybe.as(:init_def_maybe)
         }
         rule(:foreign_str) {
           (str('{') >> match['^}'].repeat(1).as(:str) >> str('}'))

data/lib/sfrp/input/transformer.rb

@@ -185,7 +185,8 @@ module SFRP
 
       # pattern
       rule(:any_pattern => simple(:x)) {
-        Raw::MatchExp::Pattern.new(nil, x.to_s, [])
+        var_str = x.to_s
+        Raw::MatchExp::Pattern.new(nil, var_str == '_' ? nil : var_str, [])
       }
       rule(:vc_pattern_with_paren => subtree(:x)) {
         Raw::MatchExp::Pattern.new(x[:vconst_ref], x[:var_ref], x[:args])

data/lib/sfrp/raw/dsl.rb

@@ -6,36 +6,36 @@ module SFRP
       Ref.new(rname, qualifier)
     end
 
-    def t(tconst_ref, args, sp = nil)
-      TypeAnnotationType.new(tconst_ref, args, sp)
+    def t(tconst_ref, args)
+      TypeAnnotationType.new(tconst_ref, args)
     end
 
-    def tv(var_str, sp = nil)
-      TypeAnnotationVar.new(var_str, sp)
+    def tv(var_str)
+      TypeAnnotationVar.new(var_str)
     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)
+    def v_e(var_str)
+      VarRefExp.new(var_str)
     end
 
-    def nr_e(node_ref, last, sp = nil)
-      NodeRefExp.new(node_ref, last, sp)
+    def nr_e(node_ref, last)
+      NodeRefExp.new(node_ref, last)
     end
 
-    def call_e(func_ref, args, sp = nil)
-      FuncCallExp.new(func_ref, args, sp)
+    def call_e(func_ref, args)
+      FuncCallExp.new(func_ref, args)
     end
 
-    def vc_call_e(vconst_ref, args, sp = nil)
-      VConstCallExp.new(vconst_ref, args, sp)
+    def vc_call_e(vconst_ref, args)
+      VConstCallExp.new(vconst_ref, args)
     end
 
-    def seq_e(exps, func_refs, sp = nil)
-      SequenceExp.new(exps, func_refs, sp)
+    def seq_e(exps, func_refs)
+      SequenceExp.new(exps, func_refs)
     end
   end
 end

data/lib/sfrp/raw/elements.rb

@@ -1,6 +1,6 @@
 module SFRP
   module Raw
-    class Function < Struct.new(:rname, :ns, :ret_ta, :pstrs, :ptas, :exp, :ffi_str, :effect, :sp)
+    class Function < Struct.new(:rname, :ns, :ret_ta, :pstrs, :ptas, :exp, :ffi_str, :effect)
       def absolute_name
         ns.absolute_name(rname)
       end
@@ -15,35 +15,35 @@ module SFRP
         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
+          absolute_name, flat_ret_ta, pstrs, flat_ptas, flat_exp, ffi_str
         )
       end
     end
 
-    class TConst < Struct.new(:rname, :ns, :pstrs, :vconsts, :native_str, :static, :sp)
+    class TConst < Struct.new(:rname, :ns, :pstrs, :vconsts, :native_str, :static)
       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)
+        dest_set << Flat::TConst.new(absolute_name, pstrs, vconst_strs, native_str, static)
       end
     end
 
-    class VConst < Struct.new(:rname, :tconst_rname, :ns, :native_str, :param_tas, :sp)
+    class VConst < Struct.new(:rname, :tconst_rname, :ns, :native_str, :param_tas)
       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
+        tconst_str = src_set.tconst(ns, Ref.new(tconst_rname)).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)
+        dest_set << Flat::VConst.new(absolute_name, tconst_str, native_str, flat_param_tas)
       end
     end
 
-    class PrimTConst < Struct.new(:rname, :ns, :native_str, :pat, :rep, :sp)
+    class PrimTConst < Struct.new(:rname, :ns, :native_str, :pat, :rep)
       def absolute_name
         ns.absolute_name(rname)
       end
@@ -54,11 +54,11 @@ module SFRP
 
       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)
+        VConst.new(vconst_str, rname, ns, vconst_str.gsub(pat, rep), [])
       end
 
       def gen_flat(_src_set, dest_set)
-        dest_set << Flat::TConst.new(absolute_name, [], nil, native_str, true, sp)
+        dest_set << Flat::TConst.new(absolute_name, [], nil, native_str, true)
       end
     end
 
@@ -78,7 +78,7 @@ module SFRP
       end
     end
 
-    class Node < Struct.new(:rname, :ns, :ta, :exp, :init_exp, :sp)
+    class Node < Struct.new(:rname, :ns, :ta, :exp, :init_exp)
       def absolute_name
         ns.absolute_name(rname)
       end
@@ -92,11 +92,11 @@ module SFRP
         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)
+        dest_set << Flat::Node.new(absolute_name, flat_ta, flat_exp, flat_init_exp)
       end
     end
 
-    class Output < Struct.new(:ns, :exps, :func_ref, :line_number, :sp)
+    class Output < Struct.new(:ns, :exps, :func_ref, :line_number)
       def rname
         "%output_line#{line_number}"
       end
@@ -106,25 +106,25 @@ module SFRP
       end
 
       def convert
-        exp = FuncCallExp.new(func_ref, exps, false, sp)
+        exp = FuncCallExp.new(func_ref, exps, false)
         ta = TypeAnnotationType.new(Ref.new('Unit'), [])
-        Node.new(rname, ns, ta, exp, nil, sp)
+        Node.new(rname, ns, ta, exp, nil)
       end
     end
 
-    class Input < Struct.new(:rname, :ns, :ta, :arg_exps, :init_exp, :func_ref, :sp)
+    class Input < Struct.new(:rname, :ns, :ta, :arg_exps, :init_exp, :func_ref)
       def convert
-        exp = FuncCallExp.new(func_ref, arg_exps, false, sp)
-        Node.new(rname, ns, ta, exp, init_exp, sp)
+        exp = FuncCallExp.new(func_ref, arg_exps, false)
+        Node.new(rname, ns, ta, exp, init_exp)
       end
     end
 
-    class Infix < Struct.new(:ns, :func_ref, :priority, :direction, :sp)
+    class Infix < Struct.new(:ns, :func_ref, :priority, :direction)
       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 = set.func(ns, func_ref).absolute_name
+        raise NameError.new(func_ref.to_s) unless func_name
         func_name
       end
 
@@ -140,24 +140,24 @@ module SFRP
       end
     end
 
-    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas, :sp)
+    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas)
       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)
+        Flat::FuncTypeAnnotation.new(ret_ta.to_flat(set, ns), flat_arg_tas)
       end
     end
 
-    class TypeAnnotationType < Struct.new(:tconst_ref, :arg_tas, :sp)
+    class TypeAnnotationType < Struct.new(:tconst_ref, :arg_tas)
       def to_flat(set, ns)
-        ab_tc_name = set.tconst(ns, tconst_ref, sp).absolute_name
+        ab_tc_name = set.tconst(ns, tconst_ref).absolute_name
         flat_arg_tas = arg_tas.map { |ta| ta.to_flat(set, ns) }
-        Flat::TypeAnnotationType.new(ab_tc_name, flat_arg_tas, sp)
+        Flat::TypeAnnotationType.new(ab_tc_name, flat_arg_tas)
       end
     end
 
-    class TypeAnnotationVar < Struct.new(:var_str, :sp)
+    class TypeAnnotationVar < Struct.new(:var_str)
       def to_flat(_set, _ns)
-        Flat::TypeAnnotationVar.new(var_str, sp)
+        Flat::TypeAnnotationVar.new(var_str)
       end
     end
   end

data/lib/sfrp/raw/expression.rb

@@ -1,23 +1,23 @@
 module SFRP
   module Raw
-    class FuncCallExp < Struct.new(:func_ref, :arg_exps, :effect, :sp)
+    class FuncCallExp < Struct.new(:func_ref, :arg_exps, :effect)
       def vconst_refs
         arg_exps.flat_map(&:vconst_refs)
       end
 
       def blame_side_effect
-        raise IllegalSideEffectError.new(func_ref.to_s, sp) if effect
+        raise IllegalSideEffectError.new(func_ref.to_s) 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
+        ab_func_name = set.func(ns, func_ref).absolute_name
         args = arg_exps.map { |e| e.to_flat(set, ns) }
-        Flat::FuncCallExp.new(ab_func_name, args, sp)
+        Flat::FuncCallExp.new(ab_func_name, args)
       end
     end
 
-    class VConstCallExp < Struct.new(:vconst_ref, :arg_exps, :sp)
+    class VConstCallExp < Struct.new(:vconst_ref, :arg_exps)
       def vconst_refs
         [vconst_ref, *arg_exps.flat_map(&:vconst_refs)]
       end
@@ -27,13 +27,13 @@ module SFRP
       end
 
       def to_flat(set, ns)
-        ab_vc_name = set.vconst(ns, vconst_ref, sp).absolute_name
+        ab_vc_name = set.vconst(ns, vconst_ref).absolute_name
         args = arg_exps.map { |e| e.to_flat(set, ns) }
-        Flat::VConstCallExp.new(ab_vc_name, args, sp)
+        Flat::VConstCallExp.new(ab_vc_name, args)
       end
     end
 
-    class NodeRefExp < Struct.new(:node_ref, :last, :sp)
+    class NodeRefExp < Struct.new(:node_ref, :last)
       def vconst_refs
         []
       end
@@ -43,15 +43,15 @@ module SFRP
       end
 
       def to_flat(set, ns)
-        ab_node_name = set.node(ns, node_ref, sp).absolute_name
+        ab_node_name = set.node(ns, node_ref).absolute_name
         Flat::NodeRefExp.new(ab_node_name, last)
       end
     end
 
-    class MatchExp < Struct.new(:left_exp, :cases, :sp)
+    class MatchExp < Struct.new(:left_exp, :cases)
       Case = Struct.new(:pattern, :exp)
 
-      class Pattern < Struct.new(:vconst_ref, :ref_var_str, :args, :sp)
+      class Pattern < Struct.new(:vconst_ref, :ref_var_str, :args)
         def vconst_refs
           (vconst_ref ? [vconst_ref] : []) + args.flat_map(&:vconst_refs)
         end
@@ -59,10 +59,10 @@ module SFRP
         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)
+            ab_vc_name = set.vconst(ns, vconst_ref).absolute_name
+            Flat::MatchExp::Pattern.new(ab_vc_name, ref_var_str, flat_args)
           else
-            Flat::MatchExp::Pattern.new(nil, ref_var_str, flat_args, sp)
+            Flat::MatchExp::Pattern.new(nil, ref_var_str, flat_args)
           end
         end
       end
@@ -81,11 +81,11 @@ module SFRP
           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)
+        Flat::MatchExp.new(left_exp.to_flat(set, ns), flat_cases)
       end
     end
 
-    class VarRefExp < Struct.new(:var_str, :sp)
+    class VarRefExp < Struct.new(:var_str)
       def vconst_refs
         []
       end
@@ -95,11 +95,11 @@ module SFRP
       end
 
       def to_flat(_set, _ns)
-        Flat::VarRefExp.new(var_str, sp)
+        Flat::VarRefExp.new(var_str)
       end
     end
 
-    class SequenceExp < Struct.new(:exps, :func_refs, :sp)
+    class SequenceExp < Struct.new(:exps, :func_refs)
       def vconst_refs
         exps.flat_map(&:vconst_refs)
       end
@@ -110,11 +110,11 @@ module SFRP
 
       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)
+        pos = set.weakest_op_position(ns, func_refs)
+        lseq = SequenceExp.new(exps.take(pos + 1), func_refs.take(pos))
+        rseq = SequenceExp.new(exps.drop(pos + 1), func_refs.drop(pos + 1))
         args = [lseq.convert(set, ns), rseq.convert(set, ns)]
-        FuncCallExp.new(func_refs[pos], args, false, sp)
+        FuncCallExp.new(func_refs[pos], args, false)
       end
 
       def to_flat(set, ns)
@@ -136,23 +136,23 @@ module SFRP
       end
     end
 
-    class IfExp < Struct.new(:cond_exp, :then_exp, :else_exp, :sp)
+    class IfExp < Struct.new(:cond_exp, :then_exp, :else_exp)
       include SugarExp
 
       def convert
         cases = [
           MatchExp::Case.new(
-            MatchExp::Pattern.new(Ref.new('True'), nil, [], sp), then_exp
+            MatchExp::Pattern.new(Ref.new('True'), nil, []), then_exp
           ),
           MatchExp::Case.new(
-            MatchExp::Pattern.new(Ref.new('False'), nil, [], sp), else_exp
+            MatchExp::Pattern.new(Ref.new('False'), nil, []), else_exp
           )
         ]
-        MatchExp.new(cond_exp, cases, sp)
+        MatchExp.new(cond_exp, cases)
       end
     end
 
-    class LetExp < Struct.new(:exp, :assignments, :sp)
+    class LetExp < Struct.new(:exp, :assignments)
       include SugarExp
 
       Assignment = Struct.new(:pattern, :exp)
@@ -160,7 +160,7 @@ module SFRP
       def convert
         raise if assignments.empty?
         assignments.reverse.reduce(exp) do |e, ass|
-          MatchExp.new(ass.exp, [MatchExp::Case.new(ass.pattern, e)], sp)
+          MatchExp.new(ass.exp, [MatchExp::Case.new(ass.pattern, e)])
         end
       end
     end

data/lib/sfrp/raw/namespace.rb

@@ -1,6 +1,6 @@
 module SFRP
   module Raw
-    class Ref < Struct.new(:relative_name, :qualifier_name, :sp)
+    class Ref < Struct.new(:relative_name, :qualifier_name)
       def to_s
         return relative_name if qualifier_name.nil?
         qualifier_name + '.' + relative_name

data/lib/sfrp/raw/set.rb

@@ -56,36 +56,36 @@ module SFRP
         end
       end
 
-      def weakest_op_position(ns, func_refs, sp)
-        ab_func_names = func_refs.map { |fr| func(ns, fr, sp).absolute_name }
+      def weakest_op_position(ns, func_refs)
+        ab_func_names = func_refs.map { |fr| func(ns, fr).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)
+      def func(ns, func_ref)
+        resolve(ns, func_ref, @func_h)
       end
 
-      def vconst(ns, vconst_ref, sp)
-        resolve(ns, vconst_ref, @vconst_h, sp)
+      def vconst(ns, vconst_ref)
+        resolve(ns, vconst_ref, @vconst_h)
       end
 
-      def node(ns, node_ref, sp)
-        resolve(ns, node_ref, @node_h, sp)
+      def node(ns, node_ref)
+        resolve(ns, node_ref, @node_h)
       end
 
-      def tconst(ns, tconst_ref, sp)
-        resolve(ns, tconst_ref, @tconst_h, sp)
+      def tconst(ns, tconst_ref)
+        resolve(ns, tconst_ref, @tconst_h)
       end
 
       private
 
-      def resolve(ns, ref, hash, sp)
+      def resolve(ns, ref, hash)
         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
+        raise NameError.new(ref.to_s) if hits.empty?
+        raise AmbiguousNameError.new(ref.to_s, hits) if hits.size > 1
         hash[hits[0]]
       end
 

data/lib/sfrp/version.rb

@@ -1,3 +1,3 @@
 module SFRP
-  VERSION = '1.2.1'
+  VERSION = '1.4.0'
 end

data/spec/sfrp/Test.sfrp

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

data/spec/sfrp/input/parse_test.sfrp

@@ -15,6 +15,6 @@ 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
+in @pin init False from $pin(0)
+@acc init 0 = @@acc + - - 1
 out $world(@pin, @acc)

data/test/IntTest/Main.sfrp

@@ -1,10 +1,10 @@
 import Base
-import Base.IO.STDIO as SIO
+import Base.STDIO as SIO
 
 foreign init as $initProgram(Int) : Unit
 init $initProgram(0)
 
-in @input 0 from SIO.$getInt()
+in @input init 0 from SIO.$getInt()
 out SIO.$putInt(@x)
 
 @x : Int = -(@@input * 1 + @input * 2)

data/test/MaybeTest/Main.sfrp

@@ -1,8 +1,8 @@
 import Base
-import Base.IO.STDIO as SIO
+import Base.STDIO as SIO
 import SubDir.Lib as Lib
 
 in @maybeInt : Maybe[Int] from Lib.$getMaybeInt()
 out SIO.$putInt(@acc)
 
-@acc 0 : Int = @@acc + Lib.getOrElse(@maybeInt, 0)
+@acc init 0 : Int = @@acc + Lib.getOrElse(@maybeInt, 0)

data/test/MaybeTest/SubDir/Lib.sfrp

@@ -1,5 +1,5 @@
 import Base
-import Base.IO.STDIO as SIO
+import Base.STDIO as SIO
 
 $getMaybeInt() : Maybe[Int] = case SIO.$getIntPair() of
   (0, _) -> Nothing

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sfrp
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Kensuke Sawada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-13 00:00:00.000000000 Z
+date: 2016-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -168,15 +168,15 @@ files:
 - README.md
 - Rakefile
 - base-library/Base.sfrp
-- base-library/Base/IO/AVR/ATMEGA8/GPIO.c
-- base-library/Base/IO/AVR/ATMEGA8/GPIO.h
-- base-library/Base/IO/AVR/ATMEGA8/GPIO.sfrp
-- base-library/Base/IO/AVR/ATMEGA8/Timer.c
-- base-library/Base/IO/AVR/ATMEGA8/Timer.h
-- base-library/Base/IO/AVR/ATMEGA8/Timer.sfrp
-- base-library/Base/IO/STDIO.c
-- base-library/Base/IO/STDIO.h
-- base-library/Base/IO/STDIO.sfrp
+- base-library/Base/AVR/ATMEGA8/GPIO.c
+- base-library/Base/AVR/ATMEGA8/GPIO.h
+- base-library/Base/AVR/ATMEGA8/GPIO.sfrp
+- base-library/Base/AVR/ATMEGA8/Timer.c
+- base-library/Base/AVR/ATMEGA8/Timer.h
+- base-library/Base/AVR/ATMEGA8/Timer.sfrp
+- base-library/Base/STDIO.c
+- base-library/Base/STDIO.h
+- base-library/Base/STDIO.sfrp
 - bin/sfrp
 - lib/sfrp.rb
 - lib/sfrp/command.rb

data/base-library/Base/IO/AVR/ATMEGA8/GPIO.c

@@ -1,8 +0,0 @@
-#include <avr/io.h>
-
-int portD(int port_num, int high_or_low) {
-  high_or_low = (high_or_low == 0 ? 0 : 1);
-  DDRD |= 1 << port_num;
-  PORTD = (~(1 << port_num) & PORTD) | (high_or_low << port_num);
-  return 0;
-}

data/base-library/Base/IO/AVR/ATMEGA8/GPIO.h

@@ -1,6 +0,0 @@
-#ifndef IO_AVR_ATMEGA8_GPIO
-#define IO_AVR_ATMEGA8_GPIO
-
-int portD(int, int);
-
-#endif

data/base-library/Base/IO/AVR/ATMEGA8/GPIO.sfrp

@@ -1,4 +0,0 @@
-import Base
-
--- PORT-D
-foreign portD as $portD(Int, Bool) : Unit