emfrp 0.1.2 → 0.1.3

data/lib/emfrp/pre_convert/pre_convert.rb

@@ -1,32 +1,32 @@
-require 'emfrp/pre_convert/make_name_dict'
-require 'emfrp/pre_convert/alpha_convert'
-require 'emfrp/pre_convert/node_check'
-
-module Emfrp
-  module PreConvert
-    extend self
-
-    PreConvertError = Class.new(CompileError)
-
-    def convert(top)
-      MakeNameDict.make_name_dict(top)
-      AlphaConvert.alpha_convert(top, top)
-      NodeCheck.node_check(top)
-      #FuncCheck - check-circular-def
-      #TypeCheck - check-circular-def
-    end
-
-    def additional_convert(top, definition)
-      MakeNameDict.set_dict(top[:dict], definition)
-      AlphaConvert.alpha_convert(top, definition)
-    end
-
-    def cancel(top, definition)
-      MakeNameDict.remove_dict(top[:dict], definition)
-    end
-
-    def err(code, msg, *facts)
-      raise PreConvertError.new(msg, code, *facts)
-    end
-  end
-end
+require 'emfrp/pre_convert/make_name_dict'
+require 'emfrp/pre_convert/alpha_convert'
+require 'emfrp/pre_convert/node_check'
+
+module Emfrp
+  module PreConvert
+    extend self
+
+    PreConvertError = Class.new(CompileError)
+
+    def convert(top)
+      MakeNameDict.make_name_dict(top)
+      AlphaConvert.alpha_convert(top, top)
+      NodeCheck.node_check(top)
+      #FuncCheck - check-circular-def
+      #TypeCheck - check-circular-def
+    end
+
+    def additional_convert(top, definition)
+      MakeNameDict.set_dict(top[:dict], definition)
+      AlphaConvert.alpha_convert(top, definition)
+    end
+
+    def cancel(top, definition)
+      MakeNameDict.remove_dict(top[:dict], definition)
+    end
+
+    def err(code, msg, *facts)
+      raise PreConvertError.new(msg, code, *facts)
+    end
+  end
+end

data/lib/emfrp/syntax.rb

@@ -1,171 +1,171 @@
-module Emfrp
-  class Syntax < Hash
-    def initialize(hash, hash2 = {})
-      self[:class] = self.class
-      self.merge!(hash)
-      self.merge!(hash2)
-      self[:class] = self.class
-    end
-
-    def [](key)
-      if self.has_key?(key)
-        self.fetch(key)
-      else
-        pp self
-        raise "unexist key #{key}"
-      end
-    end
-
-    def traverse_all_syntax(target=self, &block)
-      case target
-      when Syntax
-        block.call(target)
-        traverse_all_syntax(target.values, &block)
-      when Array
-        target.each{|e| traverse_all_syntax(e, &block)}
-      end
-    end
-
-    def deep_copy(x=self)
-      case x
-      when Syntax
-        x.class.new(Hash[x.map{|k, v| [k, deep_copy(v)]}])
-      when Array
-        x.map{|x| deep_copy(x)}
-      else
-        x
-      end
-    end
-  end
-
-  class Link
-    def initialize(syntax, name=nil)
-      @link = syntax
-      @name = name
-    end
-
-    def get
-      @link
-    end
-
-    def hash
-      @link.object_id
-    end
-
-    def eql?(other)
-      self.hash == other.hash
-    end
-
-    def inspect
-      if @name || @link.has_key?(:name)
-        "Link(#{@name || @link[:name][:desc]} : #{@link.class})"
-      else
-        "Link(#{@link.class})"
-      end
-    end
-
-    def to_s
-      inspect
-    end
-  end
-
-  class SSymbol < Syntax
-    def ==(other)
-      if other.is_a?(SSymbol)
-        self[:desc] == other[:desc]
-      else
-        super
-      end
-    end
-
-    def hash
-      self[:desc].hash
-    end
-
-    def eql?(other)
-      if other.is_a?(SSymbol)
-        self.hash == other.hash
-      else
-        super
-      end
-    end
-
-    def pretty_print(q)
-      q.text 'SSymbol(' + self[:desc] + ')'
-    end
-  end
-
-  class Top < Syntax
-    ATTRS = [
-      :inputs,
-      :outputs,
-      :uses,
-      :datas,
-      :funcs,
-      :nodes,
-      :types,
-      :infixes,
-      :ptypes,
-      :pfuncs,
-      :itypes,
-      :ifuncs,
-      :commands,
-      :newnodes,
-    ]
-
-    def initialize(*tops)
-      ATTRS.each do |a|
-        self[a] = []
-        tops.each do |h|
-          self[a] += h[a] if h[a]
-        end
-      end
-      self[:module_name] = tops.map{|x| x[:module_name]}.find{|x| x}
-    end
-
-    def add(d)
-      case d
-      when DataDef then self[:datas] << d
-      when FuncDef then self[:funcs] << d
-      when TypeDef then self[:types] << d
-      else raise "assertion error: unsupported Def-type"
-      end
-    end
-  end
-
-  class Pattern < Syntax
-    def find_refs # -> [SSymbol]
-      res = []
-      if self[:ref]
-        res << self[:ref]
-      end
-      if self.has_key?(:args)
-        res = res + self[:args].map{|a| a.find_refs}.flatten
-      end
-      return res
-    end
-  end
-
-  AnyPattern = Class.new(Pattern)
-  ValuePattern = Class.new(Pattern)
-  IntegralPattern = Class.new(Pattern)
-
-  Types = [
-    :InputDef, :OutputDef, :DataDef, :FuncDef, :NodeDef, :TypeDef, :InfixDef,
-    :PrimTypeDef, :PrimFuncDef, :CommandDef,
-    :NewNodeDef,
-
-    :ParamDef, :Type, :TypeVar, :TValue, :TValueParam, :NodeConst, :ForeignExp,
-
-    :NodeRef,
-
-    # Expression
-    :MatchExp, :Case,
-    :OperatorSeq, :ParenthExp,
-    :FuncCall, :ValueConst, :SkipExp, :VarRef,
-    :LiteralChar, :LiteralIntegral, :LiteralFloating,
-  ]
-  Types.each do |t|
-    const_set(t, Class.new(Syntax))
-  end
-end
+module Emfrp
+  class Syntax < Hash
+    def initialize(hash, hash2 = {})
+      self[:class] = self.class
+      self.merge!(hash)
+      self.merge!(hash2)
+      self[:class] = self.class
+    end
+
+    def [](key)
+      if self.has_key?(key)
+        self.fetch(key)
+      else
+        pp self
+        raise "unexist key #{key}"
+      end
+    end
+
+    def traverse_all_syntax(target=self, &block)
+      case target
+      when Syntax
+        block.call(target)
+        traverse_all_syntax(target.values, &block)
+      when Array
+        target.each{|e| traverse_all_syntax(e, &block)}
+      end
+    end
+
+    def deep_copy(x=self)
+      case x
+      when Syntax
+        x.class.new(Hash[x.map{|k, v| [k, deep_copy(v)]}])
+      when Array
+        x.map{|x| deep_copy(x)}
+      else
+        x
+      end
+    end
+  end
+
+  class Link
+    def initialize(syntax, name=nil)
+      @link = syntax
+      @name = name
+    end
+
+    def get
+      @link
+    end
+
+    def hash
+      @link.object_id
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def inspect
+      if @name || @link.has_key?(:name)
+        "Link(#{@name || @link[:name][:desc]} : #{@link.class})"
+      else
+        "Link(#{@link.class})"
+      end
+    end
+
+    def to_s
+      inspect
+    end
+  end
+
+  class SSymbol < Syntax
+    def ==(other)
+      if other.is_a?(SSymbol)
+        self[:desc] == other[:desc]
+      else
+        super
+      end
+    end
+
+    def hash
+      self[:desc].hash
+    end
+
+    def eql?(other)
+      if other.is_a?(SSymbol)
+        self.hash == other.hash
+      else
+        super
+      end
+    end
+
+    def pretty_print(q)
+      q.text 'SSymbol(' + self[:desc] + ')'
+    end
+  end
+
+  class Top < Syntax
+    ATTRS = [
+      :inputs,
+      :outputs,
+      :uses,
+      :datas,
+      :funcs,
+      :nodes,
+      :types,
+      :infixes,
+      :ptypes,
+      :pfuncs,
+      :itypes,
+      :ifuncs,
+      :commands,
+      :newnodes,
+    ]
+
+    def initialize(*tops)
+      ATTRS.each do |a|
+        self[a] = []
+        tops.each do |h|
+          self[a] += h[a] if h[a]
+        end
+      end
+      self[:module_name] = tops.map{|x| x[:module_name]}.find{|x| x}
+    end
+
+    def add(d)
+      case d
+      when DataDef then self[:datas] << d
+      when FuncDef then self[:funcs] << d
+      when TypeDef then self[:types] << d
+      else raise "assertion error: unsupported Def-type"
+      end
+    end
+  end
+
+  class Pattern < Syntax
+    def find_refs # -> [SSymbol]
+      res = []
+      if self[:ref]
+        res << self[:ref]
+      end
+      if self.has_key?(:args)
+        res = res + self[:args].map{|a| a.find_refs}.flatten
+      end
+      return res
+    end
+  end
+
+  AnyPattern = Class.new(Pattern)
+  ValuePattern = Class.new(Pattern)
+  IntegralPattern = Class.new(Pattern)
+
+  Types = [
+    :InputDef, :OutputDef, :DataDef, :FuncDef, :NodeDef, :TypeDef, :InfixDef,
+    :PrimTypeDef, :PrimFuncDef, :CommandDef,
+    :NewNodeDef,
+
+    :ParamDef, :Type, :TypeVar, :TValue, :TValueParam, :NodeConst, :ForeignExp,
+
+    :NodeRef,
+
+    # Expression
+    :MatchExp, :Case,
+    :OperatorSeq, :ParenthExp,
+    :FuncCall, :ValueConst, :SkipExp, :VarRef,
+    :LiteralChar, :LiteralIntegral, :LiteralFloating,
+  ]
+  Types.each do |t|
+    const_set(t, Class.new(Syntax))
+  end
+end

data/lib/emfrp/typing/typing_error.rb

@@ -1,47 +1,47 @@
-require 'colorize'
-require 'emfrp/compile_error'
-
-module Emfrp
-  module Typing
-    class TypeMatchingError < CompileError
-      def initialize(code, expected_utype, real_utype, place, *factors)
-        @code = code
-        @expected_utype = expected_utype
-        @real_utype = real_utype
-        @place = place
-        @factors = factors
-      end
-
-      def code
-        @code
-      end
-
-      def print_error(output_io, file_loader)
-        output_io << "[Type Matching Error]".colorize(:red) + ": For #{@place}:\n"
-        output_io << "Expected: " + "#{@expected_utype.inspect}".colorize(:green) + "\n"
-        output_io << "Real: " + "#{@real_utype.inspect}".colorize(:green) + "\n"
-        @factors.each do |factor|
-          print_lexical_factor(factor, output_io, file_loader)
-        end
-      end
-    end
-
-    class TypeDetermineError < CompileError
-      def initialize(code, undetermined_utype, factor)
-        @code = code
-        @utype = undetermined_utype
-        @factor = factor
-      end
-
-      def code
-        @code
-      end
-
-      def print_error(output_io, file_loader)
-        output_io << "[Undetermined Type Error]".colorize(:red) + ":\n"
-        output_io << "Undetermined: " + "#{@utype.inspect}".colorize(:green) + "\n"
-        print_lexical_factor(@factor, output_io, file_loader)
-      end
-    end
-  end
-end
+require 'colorize'
+require 'emfrp/compile_error'
+
+module Emfrp
+  module Typing
+    class TypeMatchingError < CompileError
+      def initialize(code, expected_utype, real_utype, place, *factors)
+        @code = code
+        @expected_utype = expected_utype
+        @real_utype = real_utype
+        @place = place
+        @factors = factors
+      end
+
+      def code
+        @code
+      end
+
+      def print_error(output_io, file_loader)
+        output_io << "[Type Matching Error]".colorize(:red) + ": For #{@place}:\n"
+        output_io << "Expected: " + "#{@expected_utype.inspect}".colorize(:green) + "\n"
+        output_io << "Real: " + "#{@real_utype.inspect}".colorize(:green) + "\n"
+        @factors.each do |factor|
+          print_lexical_factor(factor, output_io, file_loader)
+        end
+      end
+    end
+
+    class TypeDetermineError < CompileError
+      def initialize(code, undetermined_utype, factor)
+        @code = code
+        @utype = undetermined_utype
+        @factor = factor
+      end
+
+      def code
+        @code
+      end
+
+      def print_error(output_io, file_loader)
+        output_io << "[Undetermined Type Error]".colorize(:red) + ":\n"
+        output_io << "Undetermined: " + "#{@utype.inspect}".colorize(:green) + "\n"
+        print_lexical_factor(@factor, output_io, file_loader)
+      end
+    end
+  end
+end