rlsm 1.0.0 → 1.1.0

data/lib/rlsm/regexp.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require File.join(File.dirname(__FILE__), 'regexp_parser')
+require File.join(File.dirname(__FILE__), 'dfa')
+
+module RLSM
+  class RegExp
+    #Returns a RegExp which is the empty word.
+    def self.empty_word
+      new RLSM::RE::ParserHelpers::EmptyWordSymbol
+    end
+
+    #Returns a RegExp which represents the empty language.
+    def self.empty_set
+      new ''
+    end
+
+    #Synonym for new.
+    def self.[](description)
+      new(description)
+    end
+
+    #Creates a new RegExp. The +description+ is a string consiting of latin letters, numbers and the following special characters
+    #1. +(+, +)+  for grouping subexpressions
+    #2. +|+ for union of regular expressions
+    #3. +*+ for the Kleene-Closure of a regular expression
+    #4. +@+ the empty word.
+    #
+    #Whitspaces will be ignored and the empty string represents the empty language.
+    def initialize(description)
+      @parse_tree = RE::Parser[ description ]
+      @string = @parse_tree.to_s
+    end
+
+    attr_reader :parse_tree, :string
+
+    #Concatenate +self+ with +other+.
+    def +(other)
+      RLSM::RegExp.new "(#@string)(#{other.string})"
+    end
+
+    #Returns the union of +self+ and +other+
+    def |(other)
+      RLSM::RegExp.new "#@string|#{other.string}"
+    end
+
+    #Returns the Kleene closure of +self+.
+    def star
+      RLSM::RegExp.new "(#@string)*"
+    end
+
+    #Calculates a minimal DFA which represents the same languge as +self+.
+    def to_dfa
+      RLSM::DFA.new(subset_construction).minimize!
+    end
+
+    #Simply returns self.
+    def to_regexp
+      self
+    end
+
+    #Calculates the syntactic monoid of the represented language.
+    def to_monoid
+      to_dfa.to_monoid
+    end
+
+    #Checks if +self+ is equal to +other+, i.e. they represent the same language.
+    def ==(other)
+      return true if @string == other.string
+
+      first = @parse_tree.first.map { |pos| pos.to_s }.uniq 
+      other_first = other.parse_tree.first.map { |pos| pos.to_s }.uniq
+      return false if first != other_first
+
+      last = @parse_tree.last.map { |pos| pos.to_s }.uniq 
+      other_last = other.parse_tree.last.map { |pos| pos.to_s }.uniq
+      return false if last != other_last
+
+      to_dfa =~ other.to_dfa
+    end
+
+    private
+    def set_up_subset_construction
+      follow = @parse_tree.follow
+      initial = RE::Position.new('i',-1)
+      @parse_tree.first.each { |char| follow << [initial, char] }
+
+      [[initial], @parse_tree.null? ? [[initial]] : [], follow, @parse_tree.last]
+    end
+
+    def subset_construction
+      initial, finals, follow, last = set_up_subset_construction
+      transitions = []
+
+      unmarked = [initial]
+      marked = []
+      until unmarked.empty?
+        marked << unmarked.shift
+        new_states(marked.last,follow).each_pair do |char,state|
+          unmarked << state unless  (unmarked | marked).include? state #bug
+          finals |= [state] if last.any? { |pos| state.any? { |st_pos| st_pos === pos } }
+          transitions << [marked.last,state, char]  
+        end
+      end
+      
+      string = "}s0 "
+      string += finals.map { |state| "*s#{marked.index(state)}" }.join(' ')
+      string += ' '
+
+      string += transitions.map do |tr|
+        "s#{marked.index(tr[0])}-#{tr[2]}->s#{marked.index(tr[1])}"
+      end.join(' ')
+    end
+
+    def new_states(origin,follow)
+      tmp = origin.map { |pos| follow.find_all { |pair| pair[0] === pos }.
+        map { |pair| pair[-1] } }.flatten
+
+        tmp.inject({}) do |result, pos|
+        (result[pos.to_s] ||= []) << pos
+        result
+      end
+    end
+  end # of class RegExp
+end   # of module RLSM
+

data/lib/rlsm/regexp_parser.rb

@@ -0,0 +1,450 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+module RLSM
+  module RE #:nodoc:
+    module ParserHelpers #:nodoc:
+      OpenBracket = '('
+      CloseBracket = ')'
+      UnionSymbol = '|'
+      StarSymbol = '*'
+      EmptyWordSymbol = '@'
+      LetterRegexp = /[a-zA-Z0-9]/
+
+      def open_bracket?(char)
+        char.to_s == OpenBracket
+      end
+
+      def close_bracket?(char)
+        char.to_s == CloseBracket
+      end
+
+      def union_symbol?(char)
+        char.to_s == UnionSymbol
+      end
+
+      def star_symbol?(char)
+        char.to_s == StarSymbol
+      end
+
+      def empty_symbol?(char)
+        char.to_s == EmptyWordSymbol
+      end
+
+      def letter?(char)
+        char.to_s =~ LetterRegexp
+      end
+
+      def empty_set?(input)
+        !input.any? { |position| letter?(position) or empty_symbol?(position) } 
+      end
+
+      def empty_word?(input)
+        input.any? { |position| empty_symbol?(position) } and
+          input.all? { |position| !letter?(position) } and not
+          input.join.include?(OpenBracket + CloseBracket)
+      end
+
+      def single_letter?(input)
+        input.size == 1 and letter?(input[0])
+      end
+
+      def union?(input)
+        depth = 0
+        input.each do |position|
+          return true if depth == 0 and union_symbol?(position)
+          depth += position.weight
+        end
+
+        false
+      end
+
+      def star?(input)
+        return false unless star_symbol?(input[-1])
+        return true if input.size == 2
+        
+        return star?(input[0..-2]) if star_symbol?(input[-2])
+
+        open_bracket?(input[0]) and close_bracket?(input[-2]) and
+          !Parser.unbalanced_brackets?(input[1..-3])
+      end      
+    end
+
+    class Position #:nodoc:
+      include Comparable
+
+      def initialize(char, index = nil)
+        @letter = char
+        @index = index
+      end
+      
+      attr_reader :letter, :index
+
+      def <=>(other)
+        case other
+        when String
+          @letter <=> other
+        when Numeric
+          @index <=> other
+        when Position
+          @letter == other.letter ? @index <=> other.index : @letter <=> other.letter
+        else
+          nil
+        end
+      end
+
+      def weight
+        return 1 if Parser.open_bracket?(@letter)
+        return -1 if Parser.close_bracket?(@letter)
+
+        0
+      end
+
+      def to_s
+        @letter
+      end
+
+      def inspect
+        "P(#@letter,#@index)"
+      end
+    end
+    
+    class Parser #:nodoc:
+      extend ParserHelpers
+
+      def self.[](string)
+        index = -1
+        input = string.gsub(/\s+/,'').scan(/./).map do |char| 
+          letter?(char) ? Position.new(char,index += 1) : Position.new(char)
+        end
+
+        if unbalanced_brackets?(input)
+          raise RegExpError, "Parse Error: Unbalanced brackets."
+        end
+        
+        parse(input)      
+      end
+
+      def self.parse(input)
+        input = remove_surrounding_brackets(input)
+
+        if empty_set?(input)
+          EmptySet[]
+        elsif empty_word?(input)
+          EmptyWord[]
+        elsif single_letter?(input)
+          Prim[ input.first ]      
+        elsif star?(input)
+          create_star_node( input )
+        elsif union?(input)
+          create_union_node(input)
+        else #must be a concat
+          create_concat_node(input)
+        end
+      end
+
+      private
+      def self.create_star_node(input)      
+        content = parse(input[0..-2])
+
+        if [Star, EmptySet, EmptyWord].include? content.class
+          content
+        elsif Union === content
+          star_content = Union[ content.content.reject { |subexpr| subexpr == EmptyWord[] } ]
+          Star[ star_content ]
+        else
+          Star[ content ]
+        end
+      end
+
+      def self.create_union_node(input)
+        subexpressions = union_split(input).map { |subexpression| parse(subexpression) }
+
+        subexpressions = subexpressions.inject([]) do |result,subexpr|
+          unless EmptySet === subexpr or result.include?(subexpr)
+            result << subexpr
+          end
+
+          result
+        end
+
+        if subexpressions.any? { |subexpr| EmptyWord === subexpr }
+          subexpressions = subexpressions.reject { |subexpr| subexpr == EmptyWord[] }
+          unless subexpressions.any? { |subexpr| subexpr.null? }
+            subexpressions.unshift EmptyWord[]
+          end
+        end
+
+        star_exprs, subexpressions = subexpressions.partition { |subexpr| Star === subexpr }
+        subexpressions.reject! { |subexpr| star_exprs.any? { |star| star.content == subexpr } }
+        subexpressions |= star_exprs
+        
+        if subexpressions.size == 1
+          subexpressions.first
+        else
+          Union[ subexpressions.sort ]
+        end
+      end
+
+      def self.create_concat_node(input)
+        subexpressions = concat_split(input)
+
+        return EmptySet[] if subexpressions.any? { |subexpr| subexpr == EmptySet[] }
+
+        subexpressions = subexpressions.reject { |subexpr| subexpr == EmptyWord[] }
+
+        if subexpressions.empty?
+          EmptyWord[]
+        elsif subexpressions.size == 1
+          subexpressions.first
+        else
+          Concat[ subexpressions ]
+        end
+      end
+
+      def self.remove_surrounding_brackets(string)
+        result = string
+        result = result[1..-2] while( open_bracket?(result.first) &&
+                                      close_bracket?(result.last) &&
+                                      !unbalanced_brackets?(result[1..-2]) )
+        
+        result
+      end
+
+      def self.unbalanced_brackets?(string)
+        nesting = string.inject(0) do |depth,char|
+          depth += char.weight
+          return true if depth < 0
+          depth
+        end
+        
+        nesting != 0 ? true : false
+      end
+      
+      def self.union_split(string)
+        result = [[]]
+        depth = 0
+        string.each do |char|
+          if depth == 0 and union_symbol?(char)
+            result << []
+          else
+            result.last << char
+          end
+          depth += char.weight
+        end
+
+        result
+      end    
+      
+      def self.concat_split(string)
+        result = []
+        subexpr = []
+        
+        depth = 0
+        string.each_with_index do |char,index|
+          depth += char.weight
+
+          if depth == 0
+            subexpr << char if close_bracket?(char)
+
+            unless subexpr.empty?
+              subexpr << string[index+1] if star_symbol?(string[index + 1])
+              result << parse(subexpr)
+              subexpr = []
+            end
+
+            if letter?(char)
+              if star_symbol?(string[index+1])
+                result << Star[ Prim[ char ] ]
+              else
+                result << Prim[ char ]
+              end
+            end
+          else #depth != 0
+            subexpr << char
+          end
+        end
+
+        result
+      end
+    end
+
+    class SyntaxNode #:nodoc:
+      include Comparable
+
+      def self.[](input = nil)
+        self.new(input)
+      end
+
+      def initialize(input = nil)
+        @content = input
+      end
+      
+      attr_accessor :content
+
+      def null?
+        true
+      end
+
+      def first
+        []
+      end
+
+      def last
+        []
+      end
+
+      def follow
+        nil
+      end
+      
+      def <=>(other)
+        to_s <=> other.to_s
+      end
+
+      def to_s
+        @content.to_s
+      end
+
+      def inspect
+        "#{self.class}[ #{@content.inspect} ]"
+      end
+    end
+
+    class EmptySet < SyntaxNode #:nodoc:
+      def initialize(input = nil)
+        super ''
+      end
+    end
+
+    class EmptyWord < SyntaxNode #:nodoc:
+      def initialize(input = nil)
+        super '@'
+      end
+    end
+
+    class Prim < SyntaxNode #:nodoc:
+      def null?
+        false
+      end
+
+      def first
+        [ @content ]
+      end
+
+      def last
+        [ @content ]
+      end
+
+      def follow
+        []
+      end
+    end
+
+    class Star < SyntaxNode #:nodoc:
+      def first
+        @content.first
+      end
+
+      def last
+        @content.last
+      end
+
+      def follow
+        result = []
+
+        @content.last.each do |char1|
+          @content.first.each do |char2|
+            result << [char1,char2]
+          end
+        end
+
+        (@content.follow | result).sort
+      end
+
+      def to_s
+        string  = @content.to_s
+
+        string.length > 1 ? "(#{string})*" : "#{string}*"
+      end
+    end
+
+    class Union < SyntaxNode #:nodoc:
+      def null?
+        @content.any? { |subexpr| subexpr.null? }
+      end
+
+      def first
+        @content.map { |subexpr| subexpr.first }.flatten.sort
+      end
+
+      def last
+        @content.map { |subexpr| subexpr.last }.flatten.sort
+      end
+
+      def follow
+        @content.inject([]) { |result, subexpr| result | subexpr.follow }.sort
+      end
+
+      def to_s
+        @content.map { |subexpr| subexpr.to_s }.join('|')
+      end
+    end
+
+    class Concat < SyntaxNode #:nodoc:
+      def null?
+        @content.all? { |subexpr| subexpr.null? }
+      end
+
+      def first
+        result = []
+        @content.each do |subexpr|
+          result << subexpr.first
+          break unless subexpr.null?
+        end
+
+        result.flatten.sort
+      end
+
+      def last
+        result = []
+        @content.reverse.each do |subexpr|
+          result << subexpr.last
+          break unless subexpr.null?
+        end
+
+        result.flatten.sort
+      end
+
+      def follow
+        result = []
+
+        (@content.size-1).times do |i|
+          result |= @content[i].follow
+          @content[i].last.each do |char1|
+            @content[i+1].first.each do |char2|
+              result << [char1, char2]
+            end
+          end
+        end
+
+        result |= @content[-1].follow
+
+        result.sort
+      end
+
+      def to_s
+        string = ''
+        
+        @content.each do |subexpr|
+          if Union === subexpr
+            string += "(#{subexpr.to_s})"
+          else
+            string += subexpr.to_s
+          end
+        end
+
+        string
+      end
+    end
+  end #of module RE
+end  #of module RLSM