rley 0.6.01 → 0.6.02

data/examples/general/SRL/lib/grammar.rb

@@ -1,106 +0,0 @@
-# Grammar for SRL (Simple Regex Language)
-require 'rley' # Load the gem
-module SRL
-  ########################################
-  # Work in progress.
-  # This is a very partial grammar of SRL.
-  # It will be expanded with the coming versions of Rley
-  builder = Rley::Syntax::GrammarBuilder.new do
-    add_terminals('LPAREN', 'RPAREN', 'COMMA')
-    add_terminals('DIGIT_LIT', 'INTEGER', 'LETTER_LIT')
-    add_terminals('LITERALLY', 'STRING_LIT')
-    add_terminals('BEGIN', 'STARTS', 'WITH')
-    add_terminals('MUST', 'END')
-    add_terminals('UPPERCASE', 'LETTER', 'FROM', 'TO')
-    add_terminals('DIGIT', 'NUMBER', 'ANY', 'NO')
-    add_terminals('CHARACTER', 'WHITESPACE', 'ANYTHING')
-    add_terminals('TAB', 'BACKSLASH', 'NEW', 'LINE')
-    add_terminals('OF', 'ONE')
-    add_terminals('EXACTLY', 'TIMES', 'ONCE', 'TWICE')
-    add_terminals('BETWEEN', 'AND', 'OPTIONAL', 'OR')
-    add_terminals('MORE', 'NEVER', 'AT', 'LEAST')
-    add_terminals('IF', 'FOLLOWED', 'BY', 'NOT')
-    add_terminals('ALREADY', 'HAD')
-    add_terminals('CAPTURE', 'AS', 'UNTIL')
-    add_terminals('CASE', 'INSENSITIVE', 'MULTI', 'ALL')
-    add_terminals('LAZY')
-
-    rule('srl' => 'expression').as 'start_rule'
-    rule('expression' => %w[pattern separator flags]).as 'flagged_expr'
-    rule('expression' => 'pattern').as 'simple_expr'
-    rule('pattern' => %w[pattern separator quantifiable]).as 'pattern_sequence'
-    rule('pattern' => 'quantifiable').as 'basic_pattern'
-    rule('separator' => 'COMMA').as 'comma_separator'
-    rule('separator' => []).as 'void_separator'
-    rule('flags' => %w[flags separator single_flag]).as 'flag_sequence'
-    rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
-    rule('single_flag' => %w[MULTI LINE]).as 'multi_line'
-    rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
-    rule('quantifiable' => %w[begin_anchor anchorable end_anchor]).as 'pinned_quantifiable'
-    rule('quantifiable' => %w[begin_anchor anchorable]).as 'begin_anchor_quantifiable'
-    rule('quantifiable' => %w[anchorable end_anchor]).as 'end_anchor_quantifiable'
-    rule('quantifiable' => 'anchorable').as 'simple_quantifiable'
-    rule('begin_anchor' => %w[STARTS WITH]).as 'starts_with'
-    rule('begin_anchor' => %w[BEGIN WITH]).as 'begin_with'
-    rule('end_anchor' => %w[MUST END]).as 'end_anchor'
-    rule('anchorable' => 'assertable').as 'simple_anchorable'
-    rule('anchorable' => %w[assertable assertion]).as 'asserted_anchorable'
-    rule('assertion' => %w[IF FOLLOWED BY assertable]).as 'if_followed'
-    rule('assertion' => %w[IF NOT FOLLOWED BY assertable]).as 'if_not_followed'
-    rule('assertion' => %w[IF ALREADY HAD assertable]).as 'if_had'
-    rule('assertion' => %w[IF NOT ALREADY HAD assertable]).as 'if_not_had'
-    rule('assertable' => 'term').as 'simple_assertable'
-    rule('assertable' => %w[term quantifier]).as 'quantified_assertable'
-    rule('term' => 'atom').as 'atom_term'
-    rule('term' => 'alternation').as 'alternation_term'
-    rule('term' => 'grouping').as 'grouping_term'
-    rule('term' => 'capturing_group').as 'capturing_group_atom'
-    rule('atom' => 'letter_range').as 'letter_range_atom'
-    rule('atom' => 'digit_range').as 'digit_range_atom'
-    rule('atom' => 'character_class').as 'character_class_atom'
-    rule('atom' => 'special_char').as 'special_char_atom'
-    rule('atom' => 'literal').as 'literal_atom'
-    rule('letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'lowercase_from_to'
-    rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'uppercase_from_to'
-    rule('letter_range' => 'LETTER').as 'any_lowercase'
-    rule('letter_range' => %w[UPPERCASE LETTER]).as 'any_uppercase'
-    rule('digit_range' => %w[digit_or_number FROM DIGIT_LIT TO DIGIT_LIT]).as 'digits_from_to'
-    rule('digit_range' => 'digit_or_number').as 'simple_digit_range'
-    rule('character_class' => %w[ANY CHARACTER]).as 'any_character'
-    rule('character_class' => %w[NO CHARACTER]).as 'no_character'
-    rule('character_class' => 'WHITESPACE').as 'whitespace'
-    rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
-    rule('character_class' => 'ANYTHING').as 'anything'
-    rule('character_class' => %w[ONE OF STRING_LIT]).as 'one_of'
-    rule('special_char' => 'TAB').as 'tab'
-    rule('special_char' => 'BACKSLASH').as 'backslash'
-    rule('special_char' => %w[NEW LINE]).as 'new_line'
-    rule('literal' => %w[LITERALLY STRING_LIT]).as 'literally'
-    rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
-    rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'
-    rule('alternatives' => 'quantifiable').as 'simple_alternative'
-    rule('grouping' => %w[LPAREN pattern RPAREN]).as 'grouping_parenthenses'
-    rule('capturing_group' => %w[CAPTURE assertable]).as 'capture'
-    rule('capturing_group' => %w[CAPTURE assertable UNTIL assertable]).as 'capture_until'
-    rule('capturing_group' => %w[CAPTURE assertable AS var_name]).as 'named_capture'
-    rule('capturing_group' => %w[CAPTURE assertable AS var_name UNTIL assertable]).as 'named_capture_until'
-    rule('var_name' => 'STRING_LIT').as 'var_name'
-    rule('quantifier' => 'ONCE').as 'once'
-    rule('quantifier' => 'TWICE').as 'twice'
-    rule('quantifier' => %w[EXACTLY count TIMES]).as 'exactly'
-    rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as 'between_and'
-    rule('quantifier' => 'OPTIONAL').as 'optional'
-    rule('quantifier' => %w[ONCE OR MORE]).as 'once_or_more'
-    rule('quantifier' => %w[NEVER OR MORE]).as 'never_or_more'
-    rule('quantifier' => %w[AT LEAST count TIMES]).as 'at_least'
-    rule('digit_or_number' => 'DIGIT').as 'digit_keyword'
-    rule('digit_or_number' => 'NUMBER').as 'number_keyword'
-    rule('count' => 'DIGIT_LIT').as 'single_digit'
-    rule('count' => 'INTEGER').as 'integer_count'
-    rule('times_suffix' => 'TIMES').as 'times_keyword'
-    rule('times_suffix' => []).as 'times_dropped'
-  end
-
-  # And now build the grammar and make it accessible via a global constant
-  Grammar = builder.grammar
-end # module

data/examples/general/SRL/lib/regex/abstract_method.rb

@@ -1,35 +0,0 @@
-# File: abstract_method.rb
-
-# Mix-in module. Provides the method 'abstract_method' that raises an exception
-# with an appropriate message when called.
-module AbstractMethod
-  # Call this method in the body of your abstract methods.
-  # Example:
-  # require 'AbstractMethod'
-  # class SomeClass
-  # include AbstractMethod # To add the behaviour from the mix-in module AbstractMethod
-  # ...
-  # Consider that SomeClass has an abstract method called 'some_method'
-  #
-  # def some_method() abstract_method
-  # end
-  def abstract_method()
-    # Determine the short class name of self
-    className = self.class.name.split(/::/).last
-
-    # Retrieve the top text line of the call stack
-    top_line = caller(1..1)
-
-    # Extract the calling method name
-    callerNameInQuotes = top_line.scan(/`.+?$/).first
-    callerName = callerNameInQuotes.gsub(/`|'/, '') # Remove enclosing quotes
-
-    # Build the error message
-    prefix = "The method #{className}##{callerName} is abstract."
-    suffix = " It should be implemented in subclasses of #{className}."
-    error_message = prefix + suffix
-    raise NotImplementedError, error_message
-  end
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/alternation.rb

@@ -1,27 +0,0 @@
-# File: alternation.rb
-
-require_relative 'polyadic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # Abstract class. A n-ary matching operator.
-  # It succeeds when one child expression succeeds to match the subject text
-  class Alternation < PolyadicExpression
-    # Constructor.
-    def initialize(*theChildren)
-      super(theChildren)
-    end
-
-    protected
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the concatented expressions.
-    def text_repr()
-      result_children = children.map(&:to_str)
-      result = '(?:' + result_children.join('|') + ')'
-
-      return result
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/anchor.rb

@@ -1,45 +0,0 @@
-# File: anchor.rb
-
-require_relative 'atomic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # An anchor is a zero-width assertion based on the current position.
-  class Anchor < AtomicExpression
-    # A Hash for converting a lexeme to a symbolic value
-    AnchorToSymbol = {
-      # Lexeme => Symbol value
-      '^' => :soLine, # Start of line
-      '$' => :eoLine, # End of line
-      '\A' => :soSubject,
-      '\b' => :wordBoundary,
-      '\B' => :nonAtWordBoundary,
-      '\G' => :firstMatch,
-      '\z' => :eoSubject,
-      '\Z' => :eoSubjectOrBeforeNLAtEnd
-    }.freeze
-
-    # A symbolic value that identifies the type of assertion to perform
-    attr_reader(:kind)
-
-    # Constructor
-    # @param aKind [String] Lexeme representation of the anchor
-    def initialize(aKind)
-      @kind = valid_kind(aKind)
-    end
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the expression.
-    def to_str()
-      return AnchorToSymbol.rassoc(kind).first
-    end
-
-    private
-
-    # Return the symbolic value corresponding to the given lexeme.
-    def valid_kind(aKind)
-      return AnchorToSymbol[aKind]
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/atomic_expression.rb

@@ -1,16 +0,0 @@
-# File: atomic_expression.rb
-
-require_relative 'expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # Abstract class. A valid regular expression that
-  # cannot be further decomposed into sub-expressions.
-  class AtomicExpression < Expression
-    # Redefined method. Return true since it may not have any child.
-    def atomic?
-      return true
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/capturing_group.rb

@@ -1,51 +0,0 @@
-# File: capturing_group.rb
-
-require_relative 'monadic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # An association between a capture variable and an expression
-  # the subject text in the same serial arrangement
-  class CapturingGroup < MonadicExpression
-    # The capture variable id. It is a Fixnum when the capture group gets 
-    # a sequence number,
-    # a String when it is an user-defined name
-    attr_reader(:id)
-
-    # When true, then capturing group forbids backtracking requests from its parent
-    # expression.
-    attr_reader(:no_backtrack)
-
-    # Constructor.
-    # [aChildExpression]  A sub-expression to match. When successful 
-    #   the matching text is assigned to the capture variable.
-    # [theId] The id of the capture variable.
-    # [noBacktrack] A flag that specifies whether the capturing group forbids 
-    #   backtracking requests from its parent expression.
-    def initialize(aChildExpression, theId = nil, noBacktrack = false)
-      super(aChildExpression)
-      @id = theId
-      @no_backtrack = noBacktrack
-    end
-
-    # Return true iff the capturing group has a name (and not )
-    def named?()
-      return id.kind_of?(String)
-    end
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the captured expression.
-    def to_str()
-      prefix = named? ? "?<#{id}>" : ''
-      atomic = no_backtrack ? '?>' : ''
-      if child.is_a?(Regex::NonCapturingGroup)
-        # Minor optimization
-        result = '(' + atomic + prefix + child.child.to_str + ')'
-      else
-        result = '(' + atomic + prefix + child.to_str + ')'
-      end
-      return result
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/char_class.rb

@@ -1,38 +0,0 @@
-# File: char_class.rb
-
-require_relative 'polyadic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # Abstract class. A n-ary matching operator.
-  # It succeeds when one child expression succeeds to match the subject text.
-  class CharClass < PolyadicExpression
-    # These are characters with special meaning in character classes
-    Metachars = ']\^-'.codepoints
-    # A flag that indicates whether the character is negated
-    attr_reader(:negated)
-
-    # Constructor.
-    def initialize(to_negate, *theChildren)
-      super(theChildren)
-      @negated = to_negate
-    end
-
-    protected
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the character class.
-    def text_repr()
-      result_children = children.inject('') do |subResult, aChild|
-        if aChild.kind_of?(Regex::Character) && Metachars.include?(aChild.codepoint)
-          subResult << "\\" # Escape meta-character...
-        end
-        subResult << aChild.to_str
-      end
-      result = '[' + (negated ? '^' : '') + result_children + ']'
-
-      return result
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/char_range.rb

@@ -1,51 +0,0 @@
-# File: char_range.rb
-
-require_relative 'polyadic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # A binary expression that represents a contiguous range of characters.
-  # Assumption: characters are ordered by codepoint
-  class CharRange < PolyadicExpression
-    # Constructor.
-    # [thelowerBound] 
-    #   A character that will be the lower bound value for the range.
-    # [theUpperBound] 
-    #   A character that will be the upper bound value for the range.
-    # TODO: optimisation. Build a Character if lower bound == upper bound.
-    def initialize(theLowerBound, theUpperBound)
-      range = validated_range(theLowerBound, theUpperBound)
-      super(range)
-    end
-
-    # Return the lower bound of the range.
-    def lower()
-      return children.first
-    end
-
-    # Return the upper bound of the range.
-    def upper()
-      return children.last
-    end
-
-    protected
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the concatented expressions.
-    def text_repr()
-      result = lower.to_str + '-' + upper.to_str
-
-      return result
-    end
-
-    private
-
-    # Validation method. Returns a couple of Characters.after their validation.
-    def validated_range(theLowerBound, theUpperBound)
-      msg = 'Character range error: lower bound is greater than upper bound.'
-      raise StandardError, msg if theLowerBound.codepoint > theUpperBound.codepoint
-      return [theLowerBound, theUpperBound]
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/char_shorthand.rb

@@ -1,50 +0,0 @@
-# File: char_shorthand.rb
-
-require_relative 'atomic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # A pre-defined character class is in essence a name for a built-in, standard character class.
-  class CharShorthand < AtomicExpression
-    # A constant Hash that defines all the predefined character shorthands.
-    # It contains pairs of the form:
-    # a pre-defined character shorthand letter => a CharRange object
-    StandardCClasses = {
-      'd' => '[0-9]',
-      'D' => '[^0-9]',
-      'h' => '[0-9a-fA-F]',
-      'H' => '[^0-9a-fA-F]',
-      's' => '[ \t\r\n\f]',
-      'S' => '[^ \t\r\n\f]',
-      'w' => '[0-9a-zA-Z_]',
-      'W' => '[^0-9a-zA-Z_]'
-    }.freeze
-
-    # An one-letter abbreviation
-    attr_reader(:shortname)
-
-    # Constructor
-    def initialize(aShortname)
-      @shortname = valid_shortname(aShortname)
-    end
-
-    protected
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the expression.
-    def text_repr()
-      return "\\#{shortname}"
-    end
-
-    private
-
-    # Return the validated short name.
-    def valid_shortname(aShortname)
-      msg = "Unknown predefined character class \\#{aShortname}"
-      raise StandardError, msg unless StandardCClasses.include? aShortname
-
-      return aShortname
-    end
-  end # class
-end # module
-
-# End of file

data/examples/general/SRL/lib/regex/character.rb

@@ -1,204 +0,0 @@
-# File: character.rb
-
-require_relative 'atomic_expression' # Access the superclass
-
-module Regex # This module is used as a namespace
-  # A regular expression that matches a specific character in a given character set
-  class Character < AtomicExpression
-    # Constant with all special 2-characters escape sequences
-    DigramSequences = {
-      "\\a" => 0x7, # alarm
-      "\\n" => 0xA, # newline
-      "\\r" => 0xD, # carriage return
-      "\\t" => 0x9, # tab
-      "\\e" => 0x1B, # escape
-      "\\f" => 0xC, # form feed
-      "\\v" => 0xB, # vertical feed
-      # Single octal digit literals
-      "\\0" => 0,
-      "\\1" => 1,
-      "\\2" => 2,
-      "\\3" => 3,
-      "\\4" => 4,
-      "\\5" => 5, 
-      "\\6" => 6, 
-      "\\7" => 7  
-    }.freeze
-
-    MetaChars = '\^$+?.'.freeze
-
-    # The integer value that uniquely identifies the character.
-    attr_reader(:codepoint)
-
-    # The initial text representation of the character (if any).
-    attr_reader(:lexeme)
-
-    # Constructor.
-    # [aValue] Initialize the character with a either a String literal or a 
-    # codepoint value.
-    # Examples:
-    # Initializing with codepoint value...
-    # RegAn::Character.new(0x3a3) # Represents: Σ 
-    # (Unicode GREEK CAPITAL LETTER SIGMA)
-    # RegAn::Character.new(931)   # Also represents: Σ (931 dec == 3a3 hex)
-    #
-    # Initializing with a single character string
-    # RegAn::Character.new(?\u03a3) # Also represents: Σ
-    # RegAn::Character.new('Σ')   # Obviously, represents a Σ
-    #
-    # Initializing with an escape sequence string
-    # Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
-    # \r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B), 
-    # \f (form feed, 0xC)
-    # \uXXXX where XXXX is a 4 hex digits integer value, \u{X...}, \ooo (octal)
-    # \xXX (hex)
-    # Any other escaped character will be treated as a literal character
-    # RegAn::Character.new('\n')    # Represents a newline
-    # RegAn::Character.new('\u03a3')  # Represents a Σ
-    def initialize(aValue)
-      case aValue
-        when String
-          if aValue.size == 1
-            # Literal single character case...
-            @codepoint = self.class.char2codepoint(aValue)
-          else
-            # Should be an escape sequence...
-            @codepoint = self.class.esc2codepoint(aValue)
-          end
-          @lexeme = aValue
-
-        when Integer
-          @codepoint = aValue
-        else
-          raise StandardError, "Cannot initialize a Character with a '#{aValue}'."
-      end
-    end
-
-    # Convertion method that returns a character given a codepoint (integer) value.
-    # Example:
-    # RegAn::Character::codepoint2char(0x3a3) # Returns: Σ (
-    # The Unicode GREEK CAPITAL LETTER SIGMA)
-    def self.codepoint2char(aCodepoint)
-      return [aCodepoint].pack('U') # Remark: chr() fails with codepoints > 256
-    end
-
-    # Convertion method that returns the codepoint for the given single character.
-    # Example:
-    # RegAn::Character::char2codepoint('Σ') # Returns: 0x3a3
-    def self.char2codepoint(aChar)
-      return aChar.ord
-    end
-
-    # Convertion method that returns the codepoint for the given escape 
-    # sequence (a String).
-    # Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
-    # \r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B), \f (form feed, 
-    # 0xC), \v (vertical feed, 0xB)
-    # \uXXXX where XXXX is a 4 hex digits integer value, \u{X...}, \ooo (octal)
-    # \xXX (hex)
-    # Any other escaped character will be treated as a literal character
-    # Example:
-    # RegAn::Character::esc2codepoint('\n') # Returns: 0xd
-    def self.esc2codepoint(anEscapeSequence)
-      msg = "Escape sequence #{anEscapeSequence} does not begin with a backslash (\)."
-      raise StandardError, msg unless anEscapeSequence[0] == "\\"
-      result = (anEscapeSequence.length == 2)? digram2codepoint(anEscapeSequence) : esc_number2codepoint(anEscapeSequence)
-
-      return result
-    end
-
-    # Return the character as a String object
-    def char()
-      self.class.codepoint2char(@codepoint)
-    end
-
-    # Returns true iff this Character and parameter 'another' represent the same character.
-    # [another] any Object. The way the equality is tested depends on the another's class
-    # Example:
-    # newOne = Character.new(?\u03a3)
-    # newOne == newOne  # true. Identity
-    # newOne == Character.new(?\u03a3)  # true. Both have same codepoint
-    # newOne == ?\u03a3 # true. The single character String match exactly the char attribute.
-    # newOne == 0x03a3  # true. The Integer is compared to the codepoint value.
-    # Will test equality with any Object that knows the to_s method
-    def ==(other)
-      result = case other
-        when Character
-          self.to_str == other.to_str
-
-        when Integer
-          self.codepoint == other
-
-        when String
-          other.size > 1 ? false : to_str == other
-
-        else
-          # Unknown type: try with a convertion
-          self == other.to_s # Recursive call
-      end
-
-      return result
-    end
-
-    # Return a plain English description of the character
-    def explain()
-      return "the character '#{to_str}'"
-    end
-
-    protected
-
-    # Conversion method re-definition.
-    # Purpose: Return the String representation of the expression.
-    # If the Character was initially from a text (the lexeme), then the lexeme
-    # is returned back.
-    # Otherwise the character corresponding to the codepoint is returned.
-    def text_repr()
-      return char if lexeme.nil?
-      return lexeme.dup
-    end
-
-    # Convertion method that returns a codepoint for the given two characters
-    # (digram) escape sequence.
-    # Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
-    # \r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B),
-    # \f (form feed, 0xC), \v (vertical feed, 0xB)
-    # Any other escape sequence will return the codepoint of the escaped
-    # character.
-    # [aDigram] A sequence of two characters that starts with a backslash.
-    def self.digram2codepoint(aDigram)
-      # Check that the digram is a special escape sequence
-      result = DigramSequences.fetch(aDigram, nil)
-
-      # If it not a special sequence, then escaped character is
-      # considered literally (the backslash is 'dummy')
-      result = char2codepoint(aDigram[-1]) if result.nil?
-      return result
-    end
-
-    private_class_method :digram2codepoint
-
-    # Convertion method that returns a codepoint for the given complex
-    # escape sequence.
-    # [anEscapeSequence] A String with the format:
-    # \uXXXX where XXXX is a 4 hex digits integer value,
-    # \u{X...} X 1 or more hex digits
-    # \ooo (1..3 octal digits literal)
-    # \xXX (1..2 hex digits literal)
-    def self.esc_number2codepoint(anEscapeSequence)
-      unless /^\\(?:(?:(?<prefix>[uxX])\{?(?<hexa>\h+)\}?)|(?<octal>[0-7]{1,3}))$/ =~ anEscapeSequence
-        raise StandardError, "Unsupported escape sequence #{anEscapeSequence}." 
-      else
-      # Octal literal case?
-        return octal.oct if octal # shorterSeq =~ /[0-7]{1,3}/
-      
-        # Extract the hexadecimal number
-        hexliteral = hexa # shorterSeq.sub(/^[xXu]\{?([0-9a-fA-F]+)}?$/, '\1')
-        return hexliteral.hex
-      end
-    end
-
-    private_class_method :esc_number2codepoint
-  end # class
-end # module
-
-# End of file