emfrp 0.1.2 → 0.1.3

data/lib/emfrp/compile/c/syntax_exp_codegen.rb

@@ -1,119 +1,119 @@
-require 'emfrp/syntax'
-
-module Emfrp
-  class FuncCall
-    def codegen(ct, stmts)
-      name = ct.func_name(self[:name][:desc], self[:typing], self[:args].map{|x| x[:typing]})
-      "#{name}(#{self[:args].map{|x| x.codegen(ct, stmts)}.join(", ")})"
-    end
-  end
-
-  class ValueConst
-    def codegen(ct, stmts)
-      if ct.tdef(self[:typing]).enum?(ct)
-        ct.tdef(self[:typing])[:tvalues].index{|t| t[:name] == self[:name]}.to_s
-      else
-        name = ct.constructor_name(self[:name][:desc], self[:typing])
-        "#{name}(#{self[:args].map{|x| x.codegen(ct, stmts)}.join(", ")})"
-      end
-    end
-  end
-
-  class ParenthExp
-    def codegen(ct, stmts)
-      self[:exp].codegen(ct, stmts)
-    end
-  end
-
-  class LiteralIntegral
-    def codegen(ct, stmts)
-      self[:entity][:desc]
-    end
-  end
-
-  class LiteralFloating
-    def codegen(ct, stmts)
-      self[:entity][:desc]
-    end
-  end
-
-  class LitaralChar
-    def codegen(ct, stmts)
-      self[:entity][:desc]
-    end
-  end
-
-  class VarRef
-    def codegen(ct, stmts)
-      self[:binder].get.var_name(ct, self[:name][:desc])
-    end
-  end
-
-  class MatchExp
-    def codegen(ct, stmts)
-      vname = "_tmp%03d" % ct.uniq_id_gen
-      stmts << "#{ct.tref(self)} #{vname};"
-      left = self[:exp]
-      if left.is_a?(VarRef)
-        left_vname = left[:name][:desc]
-      else
-        left_vname = "_tmp%03d" % ct.uniq_id_gen
-        stmts.unshift "#{ct.tref(left)} #{left_vname};"
-        stmts.push "#{left_vname} = #{left.codegen(ct, stmts)};"
-      end
-      self[:cases].each_with_index do |c, i|
-        then_stmts = []
-        cond_exps = pattern_to_cond_exps(ct, left_vname, then_stmts, c, c[:pattern])
-        cond_exp = cond_exps.size == 0 ? "1" : cond_exps.join(" && ")
-        if c[:exp].is_a?(SkipExp)
-          then_stmts << "return 0;"
-        else
-          then_stmts << "#{vname} = #{c[:exp].codegen(ct, then_stmts)};"
-        end
-        if i == 0
-          stmts << ct.make_block("if (#{cond_exp}) {", then_stmts, "}")
-        else
-          stmts << ct.make_block("else if (#{cond_exp}) {", then_stmts, "}")
-        end
-      end
-      return vname
-    end
-
-    def pattern_to_cond_exps(ct, receiver, stmts, case_def, pattern)
-      if pattern[:ref]
-        vname = case_def.var_name(ct, pattern[:ref][:desc])
-        stmts << "#{ct.tref(pattern)} #{vname} = #{receiver};"
-      end
-      case pattern
-      when ValuePattern
-        conds = []
-        type_def = ct.tdef(pattern)
-        accessor = type_def[:static] ? "." : "->"
-        if type_def[:tvalues].size > 1
-          tvalue_id = type_def[:tvalues].index{|x| x[:name] == pattern[:name]}
-          if type_def.enum?(ct)
-            conds << "#{receiver} == #{tvalue_id}"
-          else
-            conds << "#{receiver}" + accessor + "tvalue_type == " + tvalue_id.to_s
-          end
-        end
-        new_receiver = "#{receiver}" + accessor + "value." + pattern[:name][:desc]
-        pattern[:args].each_with_index do |x, i|
-          conds += pattern_to_cond_exps(ct, new_receiver + ".member#{i}", stmts, case_def, x)
-        end
-        return conds
-      when IntegralPattern
-        return ["#{receiver} == #{pattern[:val][:entity][:desc]}"]
-      else
-        return []
-      end
-    end
-  end
-
-  class Case
-    def var_name(ct, name)
-      "pvar#{ct.serial(nil, self)}_" + ct.escape_name(name)
-    end
-  end
-
-end
+require 'emfrp/syntax'
+
+module Emfrp
+  class FuncCall
+    def codegen(ct, stmts)
+      name = ct.func_name(self[:name][:desc], self[:typing], self[:args].map{|x| x[:typing]})
+      "#{name}(#{self[:args].map{|x| x.codegen(ct, stmts)}.join(", ")})"
+    end
+  end
+
+  class ValueConst
+    def codegen(ct, stmts)
+      if ct.tdef(self[:typing]).enum?(ct)
+        ct.tdef(self[:typing])[:tvalues].index{|t| t[:name] == self[:name]}.to_s
+      else
+        name = ct.constructor_name(self[:name][:desc], self[:typing])
+        "#{name}(#{self[:args].map{|x| x.codegen(ct, stmts)}.join(", ")})"
+      end
+    end
+  end
+
+  class ParenthExp
+    def codegen(ct, stmts)
+      self[:exp].codegen(ct, stmts)
+    end
+  end
+
+  class LiteralIntegral
+    def codegen(ct, stmts)
+      self[:entity][:desc]
+    end
+  end
+
+  class LiteralFloating
+    def codegen(ct, stmts)
+      self[:entity][:desc]
+    end
+  end
+
+  class LitaralChar
+    def codegen(ct, stmts)
+      self[:entity][:desc]
+    end
+  end
+
+  class VarRef
+    def codegen(ct, stmts)
+      self[:binder].get.var_name(ct, self[:name][:desc])
+    end
+  end
+
+  class MatchExp
+    def codegen(ct, stmts)
+      vname = "_tmp%03d" % ct.uniq_id_gen
+      stmts << "#{ct.tref(self)} #{vname};"
+      left = self[:exp]
+      if left.is_a?(VarRef)
+        left_vname = ct.escape_name(left[:name][:desc])
+      else
+        left_vname = "_tmp%03d" % ct.uniq_id_gen
+        stmts.unshift "#{ct.tref(left)} #{left_vname};"
+        stmts.push "#{left_vname} = #{left.codegen(ct, stmts)};"
+      end
+      self[:cases].each_with_index do |c, i|
+        then_stmts = []
+        cond_exps = pattern_to_cond_exps(ct, left_vname, then_stmts, c, c[:pattern])
+        cond_exp = cond_exps.size == 0 ? "1" : cond_exps.join(" && ")
+        if c[:exp].is_a?(SkipExp)
+          then_stmts << "return 0;"
+        else
+          then_stmts << "#{vname} = #{c[:exp].codegen(ct, then_stmts)};"
+        end
+        if i == 0
+          stmts << ct.make_block("if (#{cond_exp}) {", then_stmts, "}")
+        else
+          stmts << ct.make_block("else if (#{cond_exp}) {", then_stmts, "}")
+        end
+      end
+      return vname
+    end
+
+    def pattern_to_cond_exps(ct, receiver, stmts, case_def, pattern)
+      if pattern[:ref]
+        vname = case_def.var_name(ct, pattern[:ref][:desc])
+        stmts << "#{ct.tref(pattern)} #{vname} = #{receiver};"
+      end
+      case pattern
+      when ValuePattern
+        conds = []
+        type_def = ct.tdef(pattern)
+        accessor = type_def[:static] ? "." : "->"
+        if type_def[:tvalues].size > 1
+          tvalue_id = type_def[:tvalues].index{|x| x[:name] == pattern[:name]}
+          if type_def.enum?(ct)
+            conds << "#{receiver} == #{tvalue_id}"
+          else
+            conds << "#{receiver}" + accessor + "tvalue_type == " + tvalue_id.to_s
+          end
+        end
+        new_receiver = "#{receiver}" + accessor + "value." + pattern[:name][:desc]
+        pattern[:args].each_with_index do |x, i|
+          conds += pattern_to_cond_exps(ct, new_receiver + ".member#{i}", stmts, case_def, x)
+        end
+        return conds
+      when IntegralPattern
+        return ["#{receiver} == #{pattern[:val][:entity][:desc]}"]
+      else
+        return []
+      end
+    end
+  end
+
+  class Case
+    def var_name(ct, name)
+      "pvar#{ct.serial(nil, self)}_" + ct.escape_name(name)
+    end
+  end
+
+end

data/lib/emfrp/compile/graphviz/graphviz.rb

@@ -1,53 +1,53 @@
-module Emfrp
-  module Graphviz
-    extend self
-
-    def compile(top, output_io)
-      node_stmts, edge_stmts = [], []
-      visited = {}
-      top[:outputs].each do |n|
-        node = top[:dict][:node_space][n[:name][:desc]].get
-        traverse(top, node, node_stmts, edge_stmts, visited)
-      end
-      output_io << "digraph #{top[:module_name][:desc]} {\n"
-      node_stmts.each do |s|
-        output_io << "  #{s}\n"
-      end
-      edge_stmts.each do |s|
-        output_io << "  #{s}\n"
-      end
-      output_io << "}\n"
-    end
-
-    def traverse(top, node, node_stmts, edge_stmts, visited)
-      return if visited[node]
-      visited[node] = true
-      name = node[:name][:desc]
-      type = node[:typing].to_uniq_str
-      node_attrs = ["label = \"#{name} : #{type}\""]
-      case node
-      when NodeDef
-        if top[:outputs].find{|o| o[:name] == node[:name]}
-          node_attrs += ["style = filled", "fillcolor = \"#e4e4e4\""]
-        end
-        node[:params].each do |n|
-          ch_name = n[:name][:desc]
-          if n[:last]
-            edge_stmts << "#{escape_name(ch_name)} -> #{escape_name(name)} [style = dashed];"
-          else
-            edge_stmts << "#{escape_name(ch_name)} -> #{escape_name(name)};"
-          end
-          ch_node = top[:dict][:node_space][ch_name].get
-          traverse(top, ch_node, node_stmts, edge_stmts, visited)
-        end
-      when InputDef
-        node_attrs << "shape = \"invhouse\""
-      end
-      node_stmts << "#{escape_name(name)} [#{node_attrs.join(", ")}];"
-    end
-
-    def escape_name(name)
-      CodegenContext.new(nil).escape_name(name)
-    end
-  end
-end
+module Emfrp
+  module Graphviz
+    extend self
+
+    def compile(top, output_io)
+      node_stmts, edge_stmts = [], []
+      visited = {}
+      top[:outputs].each do |n|
+        node = top[:dict][:node_space][n[:name][:desc]].get
+        traverse(top, node, node_stmts, edge_stmts, visited)
+      end
+      output_io << "digraph #{top[:module_name][:desc]} {\n"
+      node_stmts.each do |s|
+        output_io << "  #{s}\n"
+      end
+      edge_stmts.each do |s|
+        output_io << "  #{s}\n"
+      end
+      output_io << "}\n"
+    end
+
+    def traverse(top, node, node_stmts, edge_stmts, visited)
+      return if visited[node]
+      visited[node] = true
+      name = node[:name][:desc]
+      type = node[:typing].to_uniq_str
+      node_attrs = ["label = \"#{name} : #{type}\""]
+      case node
+      when NodeDef
+        if top[:outputs].find{|o| o[:name] == node[:name]}
+          node_attrs += ["style = filled", "fillcolor = \"#e4e4e4\""]
+        end
+        node[:params].each do |n|
+          ch_name = n[:name][:desc]
+          if n[:last]
+            edge_stmts << "#{escape_name(ch_name)} -> #{escape_name(name)} [style = dashed];"
+          else
+            edge_stmts << "#{escape_name(ch_name)} -> #{escape_name(name)};"
+          end
+          ch_node = top[:dict][:node_space][ch_name].get
+          traverse(top, ch_node, node_stmts, edge_stmts, visited)
+        end
+      when InputDef
+        node_attrs << "shape = \"invhouse\""
+      end
+      node_stmts << "#{escape_name(name)} [#{node_attrs.join(", ")}];"
+    end
+
+    def escape_name(name)
+      CodegenContext.new(nil).escape_name(name)
+    end
+  end
+end

data/lib/emfrp/compile_error.rb

@@ -1,95 +1,95 @@
-require 'colorize'
-
-module Emfrp
-  class CompileError < RuntimeError
-    attr_reader :message, :factors
-
-    def initialize(message, code, *factors)
-      @message = message
-      @code = message
-      @factors = factors
-    end
-
-    def code
-      @code
-    end
-
-    def tag_comp(a, b)
-      [a[:line_number], a[:column_number]] <=> [b[:line_number], b[:column_number]]
-    end
-
-    def collect_factor_tags(factor)
-      case factor
-      when Syntax
-        if factor.has_key?(:start_pos)
-          collect_factor_tags(factor.values) + [[factor[:start_pos], factor[:end_pos]]]
-        else
-          collect_factor_tags(factor.values)
-        end
-      when Array
-        factor.flat_map{|x| collect_factor_tags(x)}
-      else
-        []
-      end
-    end
-
-    def find_factor_file_name(factor)
-      case factor
-      when Syntax
-        if factor.has_key?(:start_pos)
-          return factor[:start_pos][:document_name]
-        else
-          return find_factor_file_name(factor.values)
-        end
-      when Array
-        factor.each do |x|
-          if res = find_factor_file_name(x)
-            return res
-          end
-        end
-      end
-      nil
-    end
-
-    def factor_name(factor)
-      klass = factor.class.name.split("::").last
-      if factor.is_a?(Syntax)
-        name = factor.has_key?(:name) ? "`#{factor[:name][:desc]}`" : ""
-      else
-        name = factor.inspect
-      end
-      klass + " " + name
-    end
-
-    def print_lexical_factor(factor, output_io, file_loader)
-      src_lines = nil
-      unless factor_file_name = find_factor_file_name(factor)
-        raise "assertion error: cannot detect file_name"
-      end
-      src_str = file_loader.get_src_from_full_path(factor_file_name)
-      src_lines = src_str.each_line.to_a
-      tags = collect_factor_tags(factor)
-      spos = tags.map{|x| x[0]}.min{|a, b| tag_comp(a, b)}
-      epos = tags.map{|x| x[1]}.max{|a, b| tag_comp(a, b)}
-      line_nums = (spos[:line_number]..epos[:line_number]).to_a
-      if line_nums.size == 1
-        output_io << "#{factor_file_name}:#{line_nums[0]}:\n"
-        output_io << "> " + src_lines[line_nums[0] - 1].chomp + "\n"
-        output_io << "  " + " " * (spos[:column_number] - 1)
-        output_io << ("^" * (epos[:column_number] - spos[:column_number] + 1)).colorize(:green) + "\n"
-      else
-        output_io << "#{factor_file_name}:#{line_nums.first}-#{line_nums.last}:\n"
-        line_nums.each do |line_num|
-          output_io << "> " + src_lines[line_num - 1]
-        end
-      end
-    end
-
-    def print_error(output_io, file_loader)
-      output_io << "\e[31m[Error]\e[m: #{@message}"
-      @factors.each do |factor|
-        print_lexical_factor(factor, output_io, file_loader)
-      end
-    end
-  end
-end
+require 'colorize'
+
+module Emfrp
+  class CompileError < RuntimeError
+    attr_reader :message, :factors
+
+    def initialize(message, code, *factors)
+      @message = message
+      @code = message
+      @factors = factors
+    end
+
+    def code
+      @code
+    end
+
+    def tag_comp(a, b)
+      [a[:line_number], a[:column_number]] <=> [b[:line_number], b[:column_number]]
+    end
+
+    def collect_factor_tags(factor)
+      case factor
+      when Syntax
+        if factor.has_key?(:start_pos)
+          collect_factor_tags(factor.values) + [[factor[:start_pos], factor[:end_pos]]]
+        else
+          collect_factor_tags(factor.values)
+        end
+      when Array
+        factor.flat_map{|x| collect_factor_tags(x)}
+      else
+        []
+      end
+    end
+
+    def find_factor_file_name(factor)
+      case factor
+      when Syntax
+        if factor.has_key?(:start_pos)
+          return factor[:start_pos][:document_name]
+        else
+          return find_factor_file_name(factor.values)
+        end
+      when Array
+        factor.each do |x|
+          if res = find_factor_file_name(x)
+            return res
+          end
+        end
+      end
+      nil
+    end
+
+    def factor_name(factor)
+      klass = factor.class.name.split("::").last
+      if factor.is_a?(Syntax)
+        name = factor.has_key?(:name) ? "`#{factor[:name][:desc]}`" : ""
+      else
+        name = factor.inspect
+      end
+      klass + " " + name
+    end
+
+    def print_lexical_factor(factor, output_io, file_loader)
+      src_lines = nil
+      unless factor_file_name = find_factor_file_name(factor)
+        raise "assertion error: cannot detect file_name"
+      end
+      src_str = file_loader.get_src_from_full_path(factor_file_name)
+      src_lines = src_str.each_line.to_a
+      tags = collect_factor_tags(factor)
+      spos = tags.map{|x| x[0]}.min{|a, b| tag_comp(a, b)}
+      epos = tags.map{|x| x[1]}.max{|a, b| tag_comp(a, b)}
+      line_nums = (spos[:line_number]..epos[:line_number]).to_a
+      if line_nums.size == 1
+        output_io << "#{factor_file_name}:#{line_nums[0]}:\n"
+        output_io << "> " + src_lines[line_nums[0] - 1].chomp + "\n"
+        output_io << "  " + " " * (spos[:column_number] - 1)
+        output_io << ("^" * (epos[:column_number] - spos[:column_number] + 1)).colorize(:green) + "\n"
+      else
+        output_io << "#{factor_file_name}:#{line_nums.first}-#{line_nums.last}:\n"
+        line_nums.each do |line_num|
+          output_io << "> " + src_lines[line_num - 1]
+        end
+      end
+    end
+
+    def print_error(output_io, file_loader)
+      output_io << "\e[31m[Error]\e[m: #{@message}"
+      @factors.each do |factor|
+        print_lexical_factor(factor, output_io, file_loader)
+      end
+    end
+  end
+end