emfrp 0.1.2 → 0.1.3

data/lib/emfrp/parser/misc.rb

@@ -1,184 +1,184 @@
-module Emfrp
-  class Parser
-
-    # Utils & Commons
-    # --------------------
-
-    SPChar = {
-      :space => "\s",
-      :tab => "\t",
-      :newline => "\n",
-      :doublequote => "\"",
-      :singlequote => "'",
-      :backslash => "\\",
-    }
-    SPChar.each do |name, c|
-      parser(name){char(c)}
-      parser("non_#{name}".to_sym){notchar(c)}
-    end
-
-    parser :key do |keyword| # -> Hash
-      str(keyword).map do |is|
-        is[0].tag
-      end
-    end
-
-    parser :symbol do |s|
-      str(s).map do |s|
-        SSymbol.new(
-          :desc => s.map(&:item).join,
-          :start_pos => s[0].tag,
-          :end_pos => s[-1].tag
-        )
-      end
-    end
-
-    parser :ws do # -> ()
-      tabspace | newline | commentout
-    end
-
-    parser :ws_without_newline do
-      tabspace | commentout
-    end
-
-    parser :commentout do # -> ()
-      char("#") > many(non_newline) >> proc{|x|
-        if x.size == 0 || x[0].item != "@"
-          ok(nil)
-        else
-          fail
-        end
-      }
-    end
-
-    parser :newline do #-> ()
-      char("\n")
-    end
-
-    parser :tabspace do # -> ()
-      char("\s") | char("\t")
-    end
-
-    parser :comma_separator do # -> ()
-      many(ws) > str(",") > many(ws)
-    end
-
-    parser :or_separator do # -> ()
-      many(ws) > str("|") > many(ws)
-    end
-
-    parser :end_of_def do # -> ()
-      many(ws_without_newline) > newline > many(ws)
-    end
-
-    parser :ident_begin_lower do # -> SSymbol
-      seq(
-        lower_alpha.name(:head),
-        many(lower_alpha | upper_alpha | digit | char("_")).name(:tail)
-      ).map do |x|
-        items = [x[:head]] + x[:tail]
-        SSymbol.new(
-          :desc => items.map{|i| i.item}.join,
-          :start_pos => items[0].tag,
-          :end_pos => items[-1].tag
-        )
-      end
-    end
-
-    parser :ident_begin_upper do # -> SSymbol
-      seq(
-        upper_alpha.name(:head),
-        many(lower_alpha | upper_alpha | digit | char("_")).name(:tail)
-      ).map do |x|
-        items = [x[:head]] + x[:tail]
-        SSymbol.new(
-          :desc => items.map{|i| i.item}.join,
-          :start_pos => items[0].tag,
-          :end_pos => items[-1].tag
-        )
-      end
-    end
-
-    parser :positive_integer do # -> SSymbol
-      seq(
-        pdigit.name(:head),
-        many(digit).name(:tail)
-      ).map do |x|
-        items = [x[:head]] + x[:tail]
-        SSymbol.new(
-          :desc => items.map{|i| i.item}.join,
-          :start_pos => items[0].tag,
-          :end_pos => items[-1].tag
-        )
-      end
-    end
-
-    parser :zero_integer do # -> SSymbol
-      symbol("0")
-    end
-
-    parser :digit_symbol do # -> SSymbol
-      ("0".."9").map{|c| symbol(c)}.inject(&:|)
-    end
-
-    parser :cfunc_name do # -> SSymbol
-      ident_begin_lower | ident_begin_upper
-    end
-
-    parser :func_name do # -> SSymbol
-      ident_begin_lower
-    end
-
-    parser :data_name do # -> SSymbol
-      ident_begin_lower
-    end
-
-    parser :method_name do # -> SSymbol
-      operator | ident_begin_lower
-    end
-
-    parser :var_name do # -> SSymbol
-      ident_begin_lower
-    end
-
-    parser :node_instance_name do # -> SSymbol
-      ident_begin_lower
-    end
-
-    parser :var_name_allow_last do # -> SSymbol
-      var_with_last | ident_begin_lower
-    end
-
-    parser :var_with_last do # -> SSymbol
-      seq(
-        ident_begin_lower.name(:prefix),
-        symbol("@last").name(:suffix)
-      ).map do |x|
-        SSymbol.new(x.to_h, :desc => x[:prefix][:desc] + x[:suffix][:desc])
-      end
-    end
-
-    OPUsable = "!#$%&*+./<=>?@\\^|-~"
-
-    parser :operator do # -> SSymbol
-      usable = OPUsable.chars.map{|c| char(c)}.inject(&:|)
-      ng = ["..", ":", "::", "=", "\\", "|", "<-", "->", "@", "~", "=>", ".", "#", "@@"]
-      many1(usable) >> proc{|items|
-        token = items.map{|i| i.item}.join
-        if ng.include?(token)
-          fail
-        else
-          ok(SSymbol.new(
-            :desc => token,
-            :start_pos => items[0].tag,
-            :end_pos => items[-1].tag
-          ))
-        end
-      }
-    end
-
-    parser :operator_general do # -> SSymbol
-      operator ^ (char("`") > func_name < char("`"))
-    end
-  end
-end
+module Emfrp
+  class Parser
+
+    # Utils & Commons
+    # --------------------
+
+    SPChar = {
+      :space => "\s",
+      :tab => "\t",
+      :newline => "\n",
+      :doublequote => "\"",
+      :singlequote => "'",
+      :backslash => "\\",
+    }
+    SPChar.each do |name, c|
+      parser(name){char(c)}
+      parser("non_#{name}".to_sym){notchar(c)}
+    end
+
+    parser :key do |keyword| # -> Hash
+      str(keyword).map do |is|
+        is[0].tag
+      end
+    end
+
+    parser :symbol do |s|
+      str(s).map do |s|
+        SSymbol.new(
+          :desc => s.map(&:item).join,
+          :start_pos => s[0].tag,
+          :end_pos => s[-1].tag
+        )
+      end
+    end
+
+    parser :ws do # -> ()
+      tabspace | newline | commentout
+    end
+
+    parser :ws_without_newline do
+      tabspace | commentout
+    end
+
+    parser :commentout do # -> ()
+      char("#") > many(non_newline) >> proc{|x|
+        if x.size == 0 || x[0].item != "@"
+          ok(nil)
+        else
+          fail
+        end
+      }
+    end
+
+    parser :newline do #-> ()
+      char("\n")
+    end
+
+    parser :tabspace do # -> ()
+      char("\s") | char("\t")
+    end
+
+    parser :comma_separator do # -> ()
+      many(ws) > str(",") > many(ws)
+    end
+
+    parser :or_separator do # -> ()
+      many(ws) > str("|") > many(ws)
+    end
+
+    parser :end_of_def do # -> ()
+      many(ws_without_newline) > newline > many(ws)
+    end
+
+    parser :ident_begin_lower do # -> SSymbol
+      seq(
+        lower_alpha.name(:head),
+        many(lower_alpha | upper_alpha | digit | char("_")).name(:tail)
+      ).map do |x|
+        items = [x[:head]] + x[:tail]
+        SSymbol.new(
+          :desc => items.map{|i| i.item}.join,
+          :start_pos => items[0].tag,
+          :end_pos => items[-1].tag
+        )
+      end
+    end
+
+    parser :ident_begin_upper do # -> SSymbol
+      seq(
+        upper_alpha.name(:head),
+        many(lower_alpha | upper_alpha | digit | char("_")).name(:tail)
+      ).map do |x|
+        items = [x[:head]] + x[:tail]
+        SSymbol.new(
+          :desc => items.map{|i| i.item}.join,
+          :start_pos => items[0].tag,
+          :end_pos => items[-1].tag
+        )
+      end
+    end
+
+    parser :positive_integer do # -> SSymbol
+      seq(
+        pdigit.name(:head),
+        many(digit).name(:tail)
+      ).map do |x|
+        items = [x[:head]] + x[:tail]
+        SSymbol.new(
+          :desc => items.map{|i| i.item}.join,
+          :start_pos => items[0].tag,
+          :end_pos => items[-1].tag
+        )
+      end
+    end
+
+    parser :zero_integer do # -> SSymbol
+      symbol("0")
+    end
+
+    parser :digit_symbol do # -> SSymbol
+      ("0".."9").map{|c| symbol(c)}.inject(&:|)
+    end
+
+    parser :cfunc_name do # -> SSymbol
+      ident_begin_lower | ident_begin_upper
+    end
+
+    parser :func_name do # -> SSymbol
+      ident_begin_lower
+    end
+
+    parser :data_name do # -> SSymbol
+      ident_begin_lower
+    end
+
+    parser :method_name do # -> SSymbol
+      operator | ident_begin_lower
+    end
+
+    parser :var_name do # -> SSymbol
+      ident_begin_lower
+    end
+
+    parser :node_instance_name do # -> SSymbol
+      ident_begin_lower
+    end
+
+    parser :var_name_allow_last do # -> SSymbol
+      var_with_last | ident_begin_lower
+    end
+
+    parser :var_with_last do # -> SSymbol
+      seq(
+        ident_begin_lower.name(:prefix),
+        symbol("@last").name(:suffix)
+      ).map do |x|
+        SSymbol.new(x.to_h, :desc => x[:prefix][:desc] + x[:suffix][:desc])
+      end
+    end
+
+    OPUsable = "!#$%&*+./<=>?@\\^|-~"
+
+    parser :operator do # -> SSymbol
+      usable = OPUsable.chars.map{|c| char(c)}.inject(&:|)
+      ng = ["..", ":", "::", "=", "\\", "|", "<-", "->", "@", "~", "=>", ".", "#", "@@"]
+      many1(usable) >> proc{|items|
+        token = items.map{|i| i.item}.join
+        if ng.include?(token)
+          fail
+        else
+          ok(SSymbol.new(
+            :desc => token,
+            :start_pos => items[0].tag,
+            :end_pos => items[-1].tag
+          ))
+        end
+      }
+    end
+
+    parser :operator_general do # -> SSymbol
+      operator ^ (char("`") > func_name < char("`"))
+    end
+  end
+end

data/lib/emfrp/parser/newnode_convert.rb

@@ -1,72 +1,72 @@
-module Emfrp
-  module NewNodeConvert
-    extend self
-
-    def parse_module(mod_name, newnode, file_loader)
-      src_str, file_name = file_loader.load(newnode[:module_path].map{|x| x[:desc]})
-      top = Parser.parse_src(src_str, file_name, file_loader)
-      uniq_key = "#{mod_name}(#{newnode[:names].map{|x| x[:desc]}.join(",")})"
-      rename_nodes(top, uniq_key)
-      top[:inputs].zip(newnode[:args]).each do |input, arg_exp|
-        input[:name][:desc] << "##{uniq_key}"
-        top[:nodes] << NodeDef.new(
-          :name => input[:name],
-          :init_exp => nil,
-          :params => nil,
-          :type => nil,
-          :exp => arg_exp,
-        )
-      end
-      top[:inputs] = []
-      top[:outputs].zip(newnode[:names]).each do |output, newnode_name|
-        output[:name][:desc] << "##{uniq_key}"
-        top[:nodes] << NodeDef.new(
-          :name => newnode_name,
-          :init_exp => nil,
-          :params => nil,
-          :type => nil,
-          :exp => VarRef.new(:name => output[:name])
-        )
-      end
-      top[:outputs] = []
-      return top
-    end
-
-    def rename_nodes(top, uniq_key)
-      datas = Hash[top[:datas].map{|x| [x[:name][:desc], true]}]
-      top[:nodes].each do |n|
-        white_list = {}
-        n[:name][:desc] << "##{uniq_key}"
-        if n[:params]
-          n[:params].each do |pn|
-            white_list[pn[:as][:desc].clone] = true
-            pn[:name][:desc] << "##{uniq_key}"
-            pn[:as][:desc] << "##{uniq_key}"
-          end
-        end
-        rename_node_exp(n[:exp], datas, white_list, uniq_key, {})
-      end
-    end
-
-    def rename_node_exp(exp, datas, white_list, uniq_key, local_vars)
-      case exp
-      when VarRef
-        name = exp[:name][:desc]
-        if !local_vars[name] && (white_list[name] || !datas[name])
-          if name =~ /^(.*)@last$/
-            exp[:name][:desc] = "#{$1}##{uniq_key}@last"
-          else
-            exp[:name][:desc] << "##{uniq_key}"
-          end
-        end
-      when Case
-        vs = Hash[exp[:pattern].find_refs.map{|x| [x[:desc], true]}]
-        rename_node_exp(exp[:exp], datas, white_list, uniq_key, local_vars.merge(vs))
-      when Syntax
-        rename_node_exp(exp.values, datas, white_list, uniq_key, local_vars)
-      when Array
-        exp.each{|e| rename_node_exp(e, datas, white_list, uniq_key, local_vars)}
-      end
-    end
-  end
-end
+module Emfrp
+  module NewNodeConvert
+    extend self
+
+    def parse_module(mod_name, newnode, file_loader)
+      src_str, file_name = file_loader.load(newnode[:module_path].map{|x| x[:desc]})
+      top = Parser.parse_src(src_str, file_name, file_loader)
+      uniq_key = "#{mod_name}(#{newnode[:names].map{|x| x[:desc]}.join(",")})"
+      rename_nodes(top, uniq_key)
+      top[:inputs].zip(newnode[:args]).each do |input, arg_exp|
+        input[:name][:desc] << "##{uniq_key}"
+        top[:nodes] << NodeDef.new(
+          :name => input[:name],
+          :init_exp => nil,
+          :params => nil,
+          :type => nil,
+          :exp => arg_exp,
+        )
+      end
+      top[:inputs] = []
+      top[:outputs].zip(newnode[:names]).each do |output, newnode_name|
+        output[:name][:desc] << "##{uniq_key}"
+        top[:nodes] << NodeDef.new(
+          :name => newnode_name,
+          :init_exp => nil,
+          :params => nil,
+          :type => nil,
+          :exp => VarRef.new(:name => output[:name])
+        )
+      end
+      top[:outputs] = []
+      return top
+    end
+
+    def rename_nodes(top, uniq_key)
+      datas = Hash[top[:datas].map{|x| [x[:name][:desc], true]}]
+      top[:nodes].each do |n|
+        white_list = {}
+        n[:name][:desc] << "##{uniq_key}"
+        if n[:params]
+          n[:params].each do |pn|
+            white_list[pn[:as][:desc].clone] = true
+            pn[:name][:desc] << "##{uniq_key}"
+            pn[:as][:desc] << "##{uniq_key}"
+          end
+        end
+        rename_node_exp(n[:exp], datas, white_list, uniq_key, {})
+      end
+    end
+
+    def rename_node_exp(exp, datas, white_list, uniq_key, local_vars)
+      case exp
+      when VarRef
+        name = exp[:name][:desc]
+        if !local_vars[name] && (white_list[name] || !datas[name])
+          if name =~ /^(.*)@last$/
+            exp[:name][:desc] = "#{$1}##{uniq_key}@last"
+          else
+            exp[:name][:desc] << "##{uniq_key}"
+          end
+        end
+      when Case
+        vs = Hash[exp[:pattern].find_refs.map{|x| [x[:desc], true]}]
+        rename_node_exp(exp[:exp], datas, white_list, uniq_key, local_vars.merge(vs))
+      when Syntax
+        rename_node_exp(exp.values, datas, white_list, uniq_key, local_vars)
+      when Array
+        exp.each{|e| rename_node_exp(e, datas, white_list, uniq_key, local_vars)}
+      end
+    end
+  end
+end

data/lib/emfrp/parser/operator.rb

@@ -1,25 +1,25 @@
-require 'parser_combinator'
-
-module Emfrp
-  class OpParser < ParserCombinator
-    def self.make_op_parser(priority_list)
-      priority_list.reverse.inject(item.map(&:item)) do |contp, x|
-        op = sat{|i| i.item.is_a?(SSymbol) && i.item[:desc] == x[:sym]}
-        if x[:dir] == "left"
-          opp = x[:op].map do |op|
-            proc{|l, r| FuncCall.new(:name => op, :args => [l, r])}
-          end
-          binopl_fail(contp, opp)
-        elsif x[:dir] == "right"
-          sp = contp >> proc{|l|
-            x[:op] >> proc{|op|
-              sp >> proc{|r|
-                ok(FuncCall.new(:name => op, :args => [l, r]))
-              }}} | contp
-        else
-          raise "invalid direction"
-        end
-      end
-    end
-  end
-end
+require 'parser_combinator'
+
+module Emfrp
+  class OpParser < ParserCombinator
+    def self.make_op_parser(priority_list)
+      priority_list.reverse.inject(item.map(&:item)) do |contp, x|
+        op = sat{|i| i.item.is_a?(SSymbol) && i.item[:desc] == x[:sym]}
+        if x[:dir] == "left"
+          opp = x[:op].map do |op|
+            proc{|l, r| FuncCall.new(:name => op, :args => [l, r])}
+          end
+          binopl_fail(contp, opp)
+        elsif x[:dir] == "right"
+          sp = contp >> proc{|l|
+            x[:op] >> proc{|op|
+              sp >> proc{|r|
+                ok(FuncCall.new(:name => op, :args => [l, r]))
+              }}} | contp
+        else
+          raise "invalid direction"
+        end
+      end
+    end
+  end
+end