resyma 0.1.1

data/lib/resyma/core/automaton/regexp.rb

@@ -0,0 +1,175 @@
+require "resyma/core/automaton/builder"
+
+module Resyma
+  module Core
+    class Regexp
+      #
+      # Converts self to automaton, which is implemented by subclasses. Note
+      # that only add states and transitions by the automaton builder, do not
+      # modify starting state and accept set
+      #
+      # @param [Resyma::Core::AutomatonBuilder] ab Output automaton
+      # @param [Resyma::Core::State] start_state Starting state, every
+      #   implements should work starting from this state
+      #
+      # @return [Resyma::Core::State] Ending state, every implements should end
+      #   their automaton with a single acceptable state
+      #
+      def inject(ab, start_state)
+        raise NotImplementedError
+      end
+
+      #
+      # Convert the regexp to a DFA
+      #
+      # @return [Resyma::Core::Automaton] A automaton without `Epsilon`
+      #
+      def to_automaton(eliminate_epsilon = true)
+        ab = AutomatonBuilder.new
+        start = ab.new_state!
+        ab.start! start
+        accept = inject ab, start
+        ab.accept! accept
+        result = ab.build
+        if eliminate_epsilon
+          result.to_DFA
+        else
+          result
+        end
+      end
+    end
+
+    class RegexpConcat < Regexp
+      #
+      # Concatentate a list of regexps
+      #
+      # @param [Array<Regexp>] regexp_list A list of instances of Regexp
+      #
+      def initialize(regexp_list)
+        @regexp_list = regexp_list
+      end
+
+      attr_reader :regexp_list
+
+      def ==(other)
+        other.is_a?(self.class) && other.regexp_list == @regexp_list
+      end
+
+      def inject(ab, start_state)
+        current_start = start_state
+        @regexp_list.each do |regexp|
+          current_start = regexp.inject(ab, current_start)
+        end
+        current_start
+      end
+    end
+
+    class RegexpSelect < Regexp
+      #
+      # Select one regexp from a list of regexps
+      #
+      # @param [Array<Regexp>] regexp_list A list of instances of Regexp
+      #
+      def initialize(regexp_list)
+        @regexp_list = regexp_list
+      end
+
+      attr_reader :regexp_list
+
+      def ==(other)
+        other.is_a?(self.class) && other.regexp_list == @regexp_list
+      end
+
+      def inject(ab, start_state)
+        accept = ab.new_state!
+        @regexp_list.each do |regexp|
+          option_start = ab.new_state!
+          ab.add_transition!(start_state, Epsilon, option_start)
+          option_end = regexp.inject(ab, option_start)
+          ab.add_transition!(option_end, Epsilon, accept)
+        end
+        accept
+      end
+    end
+
+    class RegexpRepeat < Regexp
+      #
+      # Repeat the regexp zero, one, or more times
+      #
+      # @param [Regexp] regexp A instance of Regexp
+      #
+      def initialize(regexp)
+        @regexp = regexp
+      end
+
+      attr_reader :regexp
+
+      def ==(other)
+        other.is_a?(self.class) && other.regexp == @regexp
+      end
+
+      def inject(ab, start_state)
+        accept = @regexp.inject(ab, start_state)
+        ab.add_transition!(start_state, Epsilon, accept)
+        ab.add_transition!(accept, Epsilon, start_state)
+        accept
+      end
+    end
+
+    class RegexpSomething < Regexp
+      #
+      # Matches what the matchable matches
+      #
+      # @param [Resyma::Core::Matchable] matchable A matchable object
+      #
+      def initialize(matchable)
+        @condition = matchable
+      end
+
+      attr_reader :condition
+
+      def ==(other)
+        other.is_a?(self.class) && other.condition == @condition
+      end
+
+      def inject(ab, start_state)
+        accept = ab.new_state!
+        ab.add_transition!(start_state, @condition, accept)
+        accept
+      end
+    end
+
+    class RegexpNothing < Regexp
+
+      def ==(other)
+        other.is_a?(RegexpNothing)
+      end
+
+      def inject(_ab, start_state)
+        start_state
+      end
+    end
+
+    module RegexpOp
+      def rcat(*regexps)
+        RegexpConcat.new(regexps)
+      end
+
+      def ror(*regexps)
+        RegexpSelect.new(regexps)
+      end
+
+      def rrep(regexp)
+        RegexpRepeat.new(regexp)
+      end
+
+      def rchr(matchable)
+        RegexpSomething.new(matchable)
+      end
+
+      def reps
+        RegexpNothing.new
+      end
+    end
+  end
+end

data/lib/resyma/core/automaton/state.rb

@@ -0,0 +1,22 @@
+module Resyma
+  module Core
+    class State
+      def initialize(id)
+        @id = id
+      end
+
+      attr_reader :id
+
+      #
+      # Returns a new State whose ID is `id`
+      #
+      # @param [Integer] id ID of the state
+      #
+      # @return [Resyma::Core::State] A new instance of State
+      #
+      def self.with_id(id)
+        new(id)
+      end
+    end
+  end
+end

data/lib/resyma/core/automaton/transition.rb

@@ -0,0 +1,58 @@
+module Resyma
+  module Core
+    class TransitionTable
+
+      attr_reader :table
+
+      Candidate = Struct.new("Candidate", :condition, :destination)
+
+      def initialize
+        @table = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      #
+      # Add a transition from `from_state` to `to_state` through `matchable`
+      #
+      # @param [Resyma::Core::State] from_state Starting state
+      # @param [Resyma::Core::Matchable] matchable Condition of transition
+      # @param [Resyma::Core::State] to_state Destination state
+      #
+      # @return [nil] Undefined
+      #
+      def add_transition!(from_state, matchable, to_state)
+        @table[from_state].push Candidate.new(matchable, to_state)
+        nil
+      end
+
+      #
+      # Query the destination state in the table. `nil` will be returned if the
+      # destination is not defined
+      #
+      # @param [Resyma::Core::State] from_state Starting state
+      # @param [Object] value Value to be matched, see `Resyme::Core::Matchable`
+      #
+      # @return [nil, Resyma::Core::State] The destination if exists
+      #
+      def destination(from_state, value)
+        @table[from_state].each do |candidate|
+          if candidate.condition.match_with_value? value
+            return candidate.destination
+          end
+        end
+        nil
+      end
+
+      #
+      # Candidate states that has a transition starting from `from_state`
+      #
+      # @param [Resyma::Core::State] from_state Starting state
+      #
+      # @return [Array<Resyma::Core::TransitionTable::Candidate>] A list of
+      #   candidates
+      #
+      def candidates(from_state)
+        @table[from_state]
+      end
+    end
+  end
+end

data/lib/resyma/core/automaton/visualize.rb

@@ -0,0 +1,23 @@
+module Resyma
+  module Core
+    def Epsilon.to_s
+      "ε"
+    end
+
+    class Automaton
+      def to_lwg(port = $>)
+        transition_table.table.each do |state, candidates|
+          candidates.each do |can|
+            port << "#{state.id} - #{can.destination.id}\n"
+            port <<
+              %(move.#{state.id}.#{can.destination.id} = "#{can.condition}"\n)
+          end
+        end
+        accept_set.each do |state|
+          port << "accept.#{state.id}\n"
+        end
+        port << "start.from.#{start.id}\n"
+      end
+    end
+  end
+end

data/lib/resyma/core/automaton.rb

@@ -0,0 +1,9 @@
+require "resyma/core/automaton/matchable"
+require "resyma/core/automaton/state"
+require "resyma/core/automaton/transition"
+require "resyma/core/automaton/definition"
+require "resyma/core/automaton/builder"
+require "resyma/core/automaton/epsilon_NFA"
+require "resyma/core/automaton/regexp"
+
+__END__

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

@@ -0,0 +1,89 @@
+require "resyma/core/parsetree/definition"
+
+module Resyma
+  module Core
+    class ParseTree
+      def build(parent = nil)
+        @parent = parent
+        self
+      end
+    end
+
+    #
+    # Builder of Resyma::Core::ParseTree
+    #
+    class ParseTreeBuilder
+      def initialize(symbol, index = 0, is_leaf = false,
+                     children = [], ast = nil)
+        @symbol = symbol
+        @children = children
+        @index = index
+        @is_leaf = is_leaf
+        @ast = ast
+      end
+
+      #
+      # Define and add a node to current tree as a child
+      #
+      # @param [Symbol] symbol Type of the node
+      # @param [Parser::AST::Node] ast Abstract syntax tree of the new node
+      # @param [true, false] is_leaf Is a leaf node?
+      # @param [Array] value Should only be used when `is_leaf`, meaning that
+      #   this node is a token node. Pass an array with a single value as the
+      #   value of the token
+      #
+      # @return [Resyma::Core::ParseTreeBuilder] The builder of the new node
+      #
+      def add_child!(symbol, ast = nil, is_leaf = false, value = [])
+        ptb = ParseTreeBuilder.new(symbol, @children.length, is_leaf, value,
+                                   ast)
+        @children.push ptb
+        ptb
+      end
+
+      #
+      # Add a node to current tree as a child
+      #
+      # @param [Resyma::Core::ParseTree] tree The new child
+      #
+      # @return [nil] Nothing
+      #
+      def add_parsetree_child!(tree, ast = nil)
+        tree.index = @children.length
+        tree.ast = ast
+        @children.push tree
+        nil
+      end
+
+      def build(parent = nil)
+        pt = ParseTree.new(@symbol, nil, parent, @index, @is_leaf, @ast)
+        pt.children = if @is_leaf
+                        @children
+                      else
+                        @children.map { |c| c.build(pt) }
+                      end
+        pt
+      end
+
+      def node(symbol, ast = nil, &block)
+        ptb = add_child! symbol, ast
+        ptb.instance_eval(&block) unless block.nil?
+        ptb
+      end
+
+      def leaf(symbol, value, ast = nil)
+        add_child! symbol, ast, true, [value]
+      end
+
+      def self.root(symbol, value = nil, index = 0, ast = nil, &block)
+        if block.nil?
+          ParseTreeBuilder.new(symbol, index, true, [value], ast)
+        else
+          ptb = ParseTreeBuilder.new(symbol, index, false, [], ast)
+          ptb.instance_eval(&block) unless block.nil?
+          ptb
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require "parser"
+
+module Resyma
+  module Core
+    class ConversionError < Resyma::Error; end
+
+    #
+    # Converter for Parser::AST::Node
+    #
+    class Converter
+      def initialize
+        @rules = {}
+        @fallback = nil
+      end
+
+      #
+      # Define the conversion rule for AST with particular type(s)
+      #
+      # @param [Symbol, Array<Symbol>] type_or_types Types
+      # @param [Proc] &cvt Procedure taking a AST and returning a parse tree,
+      #  i.e. Parser::AST::Node -> Resyma::Core::ParseTree
+      # @yieldparam [Parser::AST::Node]
+      # @yieldparam [Resyma::Core::ParseTree]
+      # @yieldparam [Integer]
+      #
+      # @return [nil] Nothing
+      #
+      def def_rule(type_or_types, &cvt)
+        types = if type_or_types.is_a?(Symbol)
+                  [type_or_types]
+                else
+                  type_or_types
+                end
+        types.each { |type| @rules[type] = cvt }
+      end
+
+      def def_fallback(&cvt)
+        @fallback = cvt
+      end
+
+      #
+      # Convert a Parser::AST::Node to Resyma::Core::ParseTree
+      #
+      # @param [Parser::AST::Node] ast An abstract syntax tree
+      #
+      # @return [Resyma::Core::ParseTree] A concrete syntax tree
+      #
+      def convert(ast, parent = nil, index = 0)
+        converter = @rules[ast.type]
+        if !converter.nil?
+          converter.call(ast, parent, index)
+        elsif !@fallback.nil?
+          @fallback.call(ast, parent, index)
+        else
+          raise Resyma::Core::ConversionError,
+                "Unable to convert AST whose type is #{ast.type}"
+        end
+      end
+    end
+  end
+end