resyma 0.1.1

data/lib/resyma/core/parsetree/default_converter.rb

@@ -0,0 +1,331 @@
+require "resyma/core/parsetree/definition"
+require "resyma/core/parsetree/converter"
+
+module Resyma
+  module Core
+    DEFAULT_CONVERTER = Converter.new
+
+    CONST_TOKEN_TABLE = {
+      "(" => :round_left,
+      ")" => :round_right,
+      "begin" => :kwd_begin,
+      "end" => :kwd_end,
+      "," => :comma,
+      "[" => :square_left,
+      "]" => :square_right,
+      "*" => :star,
+      "**" => :star2,
+      ":" => :colon,
+      "=>" => :arrow,
+      "{" => :curly_left,
+      "}" => :curly_right,
+      ".." => :dot2,
+      "..." => :dot3,
+      "defined?" => :kwd_defined?,
+      "." => :dot,
+      "&." => :and_dot,
+      "do" => :kwd_do,
+      "&" => :ampersand,
+      "|" => :tube,
+      "=" => :eq,
+      "true" => :the_true,
+      "false" => :the_false,
+      "nil" => :the_nil
+    }.freeze
+  end
+end
+
+Resyma::Core::DEFAULT_CONVERTER.instance_eval do
+
+  def make_token(type, value, parent, index, ast)
+    Resyma::Core::ParseTree.new(type, [value], parent, index, true, ast)
+  end
+
+  def_fallback do |ast, parent, index|
+    make_token(:any, ast.type.to_s, parent, index, ast)
+  end
+
+  simple_literal = {
+    true: :the_true,
+    false: :the_false,
+    nil: :the_nil,
+    complex: :complex,
+    rational: :rational,
+    str: :str,
+    regexp: :regexp,
+    sym: :sym,
+    self: :the_self,
+    lvar: :id,
+    ivar: :ivar,
+    cvar: :cvar,
+    gvar: :gvar,
+    nth_ref: :nth_ref,
+    back_ref: :back_ref
+  }
+
+  def_rule simple_literal.keys do |ast, parent, index|
+    make_token simple_literal[ast.type], ast.loc.expression.source,
+               parent, index, ast
+  end
+
+  number_regexp = /^\s*(\+|-)?\s*([0-9.]+)\s*$/
+  def_rule %i[int float] do |ast, parent, index|
+    m = number_regexp.match(ast.loc.expression.source)
+    if m.nil?
+      raise Resyma::Core::ConversionError,
+            "Internal error: Number pattern [#{ast.loc.expression}] is invalid"
+    end
+    Resyma::Core::ParseTreeBuilder.root(ast.type, nil, index, ast) do
+      leaf :numop, m[1] unless m[1].nil?
+      leaf :numbase, m[2]
+    end.build(parent)
+  end
+
+  def check_boundary(boundary, pt_builder)
+    return if boundary.nil?
+
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    value = boundary.source
+    type = ctt[value]
+    if type.nil?
+      raise Resyma::Core::ConversionError,
+            "Unknwon boundary-token of AST with type <begin>: #{value}"
+    end
+    pt_builder.add_child!(type, nil, true, [value])
+  end
+
+  def_rule %i[begin kwbegin] do |ast, parent, index|
+    ptb = Resyma::Core::ParseTreeBuilder.new(:begin, index, false, [], ast)
+    check_boundary ast.loc.begin, ptb
+    ast.children.each do |sub|
+      ptb.add_parsetree_child!(convert(sub), sub)
+    end
+    check_boundary ast.loc.end, ptb
+    ptb.build(parent)
+  end
+
+  def_rule %i[dstr dsym xstr] do |ast, parent, index|
+    ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+    ast.children.each do |sub|
+      ptb.add_parsetree_child!(convert(sub), sub)
+    end
+    ptb.build(parent)
+  end
+
+  def def_rule_for_seq(type, open, sep, close)
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    def_rule type do |ast, parent, index|
+      ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+      ptb.add_child!(ctt[open], nil, true, [open]) unless open.nil?
+      unless ast.children.empty?
+        first = ast.children.first
+        ptb.add_parsetree_child!(convert(first), first)
+        ast.children[1..].each do |sub|
+          ptb.add_child!(ctt[sep], nil, true, [sep]) unless sep.nil?
+          ptb.add_parsetree_child!(convert(sub), sub)
+        end
+      end
+      ptb.add_child!(ctt[close], nil, true, [close]) unless close.nil?
+      ptb.build(parent)
+    end
+  end
+
+  def_rule_for_seq(:array, "[", ",", "]")
+  def_rule_for_seq(:hash, "{", ",", "}")
+  def_rule_for_seq(:kwargs, nil, ",", nil)
+
+  def_rule %i[splat kwsplat] do |ast, parent, index|
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    star = ast.loc.operator.source
+    ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+    ptb.add_child!(ctt[star], nil, true, [star])
+    first = ast.children.first
+    ptb.add_parsetree_child!(convert(first), first)
+    ptb.build(parent)
+  end
+
+  def_rule :pair do |ast, parent, index|
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    left, right = ast.children
+    op_value = ast.loc.operator.source
+    op_type = ctt[op_value]
+    if op_type.nil?
+      raise Resyma::Core::ConversionError,
+            "Unknown operator for hash pair: #{op_value}"
+    end
+    ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+    ptb.add_parsetree_child!(convert(left), left)
+    ptb.add_child!(op_type, nil, true, [op_value])
+    ptb.add_parsetree_child!(convert(right), right)
+    ptb.build(parent)
+  end
+
+  def_rule %i[erange irange] do |ast, parent, index|
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+    left, right = ast.children
+    op_value = ast.loc.operator.source
+    ptb.add_parsetree_child!(convert(left), left) unless left.nil?
+    ptb.add_child!(ctt[op_value], nil, true, [op_value])
+    ptb.add_parsetree_child!(convert(right), right) unless right.nil?
+    ptb.build(parent)
+  end
+
+  def_rule :const do |ast, parent, index|
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    scope, sym = ast.children
+    maybe_colon = ast.loc.double_colon
+    ptb = Resyma::Core::ParseTreeBuilder.new(:const, index, false, [], ast)
+    unless scope.nil? || scope.type == :cbase
+      ptb.add_parsetree_child!(convert(scope), scope)
+    end
+    unless maybe_colon.nil?
+      op_value = maybe_colon.source
+      ptb.add_child!(ctt[op_value], nil, true, [op_value])
+    end
+    ptb.add_child!(:id, nil, true, [sym.to_s])
+    ptb.build(parent)
+  end
+
+  def try_token!(ptb, optional_range)
+    ctt = Resyma::Core::CONST_TOKEN_TABLE
+    return if optional_range.nil?
+
+    token_value = if optional_range.is_a?(String)
+                    optional_range
+                  else
+                    optional_range.source
+                  end
+    ptb.add_child!(ctt[token_value], nil, true, [token_value])
+  end
+
+  def_rule :defined? do |ast, parent, index|
+    ptb = Resyma::Core::ParseTreeBuilder.new(:defined?, index, false, [], ast)
+    try_token! ptb, ast.loc.source.keyword
+    try_token! ptb, ast.loc.source.begin
+    expr, = ast.children
+    ptb.add_parsetree_child!(convert(expr), expr)
+    try_token! ptb, ast.loc.source.end
+    ptb.build(parent)
+  end
+
+  asgn_table = {
+    lvasgn: :id,
+    ivasgn: :ivar,
+    cvasgn: :cvar,
+    gvasgn: :gvar
+  }
+
+  def_rule %i[lvasgn ivasgn cvasgn gvasgn] do |ast, parent, index|
+    name = ast.loc.name.source
+    value = ast.children[1]
+    ptb = Resyma::Core::ParseTreeBuilder.new(ast.type, index, false, [], ast)
+    name_tkn = make_token(asgn_table[ast.type], name, nil, 0, nil)
+    ptb.add_parsetree_child!(name_tkn)
+    try_token!(ptb, ast.loc.operator)
+    ptb.add_parsetree_child!(convert(value), value)
+    ptb.build(parent)
+  end
+
+  #
+  # @yieldparam [Resyma::Core::ParseTreeBuilder]
+  #
+  def with_ptb(ast, parent, index, type = ast.type)
+    ptb = Resyma::Core::ParseTreeBuilder.new(type, index, false, [], ast)
+    yield ptb
+    ptb.build(parent)
+  end
+
+  def add_ast!(ptb, ast)
+    ptb.add_parsetree_child!(convert(ast), ast) unless ast.nil?
+  end
+
+  def_rule :casgn do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      base, sym, value_ast = ast.children
+      add_ast! ptb, base unless base.nil? || base.type == :cbase
+      try_token! ptb, ast.loc.double_colon
+      name = ast.loc.name.source
+      name_tkn = make_token(:id, name, nil, 0, nil)
+      ptb.add_parsetree_child!(name_tkn)
+      try_token! ptb, ast.loc.operator
+      add_ast! ptb, value_ast
+    end
+  end
+
+  def add_id!(ptb, name)
+    tkn = make_token(:id, name.to_s, nil, 0, nil)
+    ptb.add_parsetree_child!(tkn)
+  end
+
+  def_rule %i[send csend] do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      if ast.loc.respond_to? :operator
+        rec, _, rhs = ast.children
+        add_ast! ptb, rec
+        try_token! ptb, ast.loc.dot
+        selector = ast.loc.selector.source
+        add_id! ptb, selector
+        try_token! ptb, ast.loc.operator
+        add_ast! ptb, rhs
+      end
+    end
+  end
+
+  def_rule :block do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      send, args, block = ast.children
+      add_ast! ptb, send
+      try_token! ptb, ast.loc.begin
+      add_ast! ptb, args
+      add_ast! ptb, block
+      try_token! ptb, ast.loc.end
+    end
+  end
+
+  def_rule :args do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      try_token! ptb, ast.loc.begin
+      unless ast.children.empty?
+        add_ast! ptb, ast.children.first
+        ast.children[1..].each do |arg|
+          try_token! ptb, ","
+          add_ast! ptb, arg
+        end
+      end
+      try_token! ptb, ast.loc.end
+    end
+  end
+
+  def_rule :arg do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      add_id! ptb, ast.loc.name.source
+    end
+  end
+
+  def_rule :optarg do |ast, parent, index|
+    with_ptb ast, parent, index do |ptb|
+      add_id! ptb, ast.loc.name.source
+      try_token! ptb, ast.loc.operator
+      add_ast! ptb, ast.children[1]
+    end
+  end
+
+  def def_rule_with_ptb(types)
+    def_rule types do |ast, parent, index|
+      with_ptb ast, parent, index do |ptb|
+        yield ptb, ast, parent, index
+      end
+    end
+  end
+
+  def_rule_with_ptb :restarg do |ptb, ast|
+    try_token! ptb, "*"
+    add_id! ptb, ast.loc.name.source unless ast.loc.name.nil?
+  end
+
+  def_rule_with_ptb :blockarg do |ptb, ast|
+    try_token! ptb, "&"
+    add_id! ptb, ast.loc.name.source unless ast.loc.name.nil?
+  end
+end

data/lib/resyma/core/parsetree/definition.rb

@@ -0,0 +1,77 @@
+require "set"
+
+module Resyma
+  module Core
+    class Field
+      #
+      # Create an instance of Field, which is set and used by the matching
+      #   algorithm
+      #
+      # @param [Integer] id ID of the node
+      # @param [Hash<Integer, Set<Resyma::Core::Tuple2>>] start Sets of 2
+      #   tuples, corresponding to different automata
+      # @param [Hash<Integer, Set<Resyma::Core::Tuple4>>] trans Sets of 4
+      #   tuples, corresponding to different automata
+      #
+      def initialize(id, start, trans)
+        @id = id
+        @start = start
+        @trans = trans
+      end
+
+      attr_accessor :id, :start, :trans
+
+      def self.clean_field
+        start = Hash.new { |hash, key| hash[key] = Set[] }
+        trans = Hash.new { |hash, key| hash[key] = Set[] }
+        new(-1, start, trans)
+      end
+    end
+
+    #
+    # Parse tree with fields used by the matching algorithm
+    #
+    class ParseTree
+      attr_accessor :symbol, :children, :parent, :index, :field, :ast, :cache
+
+      #
+      # Create an instance of parse tree
+      #
+      # @param [Symbol] symbol Symbol associating to the node
+      # @param [Array] children Subtrees of current node, or an array with a
+      #   single element if it is a leaf
+      # @param [Resyma::Core::ParseTree, nil] parent Parent tree, or nil if the
+      #   current node is the root
+      # @param [Integer] index There are `index` brother preceding to the
+      #   current node
+      # @param [true,false] is_leaf Whether or not the current node is a leaf
+      # @param [Parser::AST::Node,nil] ast Its corresponding abstract syntax
+      #   tree
+      #
+      def initialize(symbol, children, parent, index, is_leaf, ast = nil)
+        @symbol = symbol
+        @children = children
+        @parent = parent
+        @index = index
+        @field = Field.clean_field
+        @is_leaf = is_leaf
+        @ast = ast
+        @cache = {}
+      end
+
+      def clear!
+        @field = Field.clean_field
+        @cache = {}
+        @children.each(&:clear!) unless leaf?
+      end
+
+      def root?
+        @parent.nil?
+      end
+
+      def leaf?
+        @is_leaf
+      end
+    end
+  end
+end

data/lib/resyma/core/parsetree/source.rb

@@ -0,0 +1,73 @@
+require "set"
+require "parser/current"
+
+module Resyma
+  module Core
+    SourceLocator = Struct.new("SourceDetector", :matcher, :locate)
+
+    SOURCE_LOCATORS = []
+
+    def self.def_source_locator(regexp, &block)
+      SOURCE_LOCATORS.unshift SourceLocator.new(regexp, block)
+    end
+
+    #
+    # Locate the AST of a callable object
+    #
+    # @param [#source_location] procedure A callable object, particular a
+    #   instance of Proc or Method
+    #
+    # @return [nil, Parser::AST::Node] AST of the procedure, or nil if cannot
+    #   locate its source
+    #
+    def self.locate(procedure)
+      if procedure.respond_to? :source_location
+        filename, lino = procedure.source_location
+        SOURCE_LOCATORS.each do |locator|
+          if locator.matcher.match?(filename)
+            return locator.locate.call(procedure, filename, lino)
+          end
+        end
+      end
+
+      nil
+    end
+
+    CALLABLE_TYPES = Set[:def, :defs, :block]
+
+    def self.line_number_of_callable(ast)
+      case ast.type
+      when Set[:def, :defs] then ast.loc.keyword.line
+      when :block then ast.loc.begin.line
+      end
+    end
+
+    def self.locate_possible_procedures(ast, lino)
+      return [] unless ast.is_a?(Parser::AST::Node)
+
+      procs = []
+      if CALLABLE_TYPES.include?(ast.type) &&
+         line_number_of_callable(ast) == lino
+        procs.push ast
+      end
+      ast.children.each do |sub|
+        procs += locate_possible_procedures(sub, lino)
+      end
+      procs
+    end
+
+    class MultipleProcedureError < Resyma::Error; end
+
+    def_source_locator(/^.*$/) do |_, filename, lino|
+      tree = Parser::CurrentRuby.parse_file(filename)
+      procs = locate_possible_procedures(tree, lino)
+      case procs.size
+      when 1 then procs[0]
+      when 0 then nil
+      else raise MultipleProcedureError,
+                 "Detected multiple procedures in [#{filename}:#{lino}], " +
+                 "which is unsupported currently"
+      end
+    end
+  end
+end

data/lib/resyma/core/parsetree/traversal.rb

@@ -0,0 +1,26 @@
+require "resyma/core/parsetree/definition"
+
+module Resyma
+  module Core
+    class ParseTree
+      #
+      # Depth-firstly traverse the tree
+      #
+      # @yieldparam [Resyma::Core::ParseTree] A parse tree
+      #
+      # @return [nil] Nothing
+      #
+      def depth_first_each(&block)
+        yield self
+
+        return if leaf?
+
+        @children.each do |child|
+          child.depth_first_each(&block)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/resyma/core/parsetree.rb

@@ -0,0 +1,8 @@
+require "resyma/core/parsetree/source"
+require "resyma/core/parsetree/definition"
+require "resyma/core/parsetree/traversal"
+require "resyma/core/parsetree/builder"
+require "resyma/core/parsetree/converter"
+require "resyma/core/parsetree/default_converter"
+
+__END__

data/lib/resyma/core/utilities.rb

@@ -0,0 +1,30 @@
+require "set"
+
+module Resyma
+  module Core
+    module Utils
+      def self.big_union(sets)
+        union = Set[]
+        sets.each { |set| union.merge(set) }
+        union
+      end
+
+      #
+      # Whether an automaton accepts the input
+      #
+      # @param [Resyma::Core::Automaton] automaton An well-formed automaton
+      # @param [Array] input_array A list of input tokens
+      #
+      # @return [true,false] Result
+      #
+      def self.automaton_accept?(automaton, input_array)
+        current_state = automaton.start
+        input_array.each do |word|
+          current_state = automaton.destination(current_state, word)
+          return false if current_state.nil?
+        end
+        automaton.accept? current_state
+      end
+    end
+  end
+end