Name

SPVM::Regex - Regular Expressions

Description

The Regex class of SPVM has methods for regular expressions.

Google RE2 is used as the regular expression library.

Usage

use Regex;

# Pattern match
{
  my $re = Regex->new("ab*c");
  my $string = "zabcz";
  my $match = $re->match("zabcz");
}

# Pattern match - UTF-8
{
  my $re = Regex->new("あ+");
  my $string = "いあああい";
  my $match = $re->match($string);
}

# Pattern match - Character class and the nagation
{
  my $re = Regex->new("[A-Z]+[^A-Z]+");
  my $string = "ABCzab";
  my $match = $re->match($string);
}

# Pattern match with captures
{
  my $re = Regex->new("^(\w+) (\w+) (\w+)$");
  my $string = "abc1 abc2 abc3";
  my $match = $re->match($string);
  
  if ($match) {
    my $cap1 = $match->cap1;
    my $cap2 = $match->cap2;
    my $cpa3 = $match->cap3;
  }
}

# Replace
{
  my $re = Regex->new("abc");
  my $string = "ppzabcz";
  
  # "ppzABCz"
  my $result = $re->replace($string, "ABC");
}

# Replace with a callback and capture
{
  my $re = Regex->new("a(bc)");
  my $string = "ppzabcz";
  
  # "ppzABbcCz"
  my $result = $re->replace($string, method : string ($re : Regex, $match : Regex::Match) {
    return "AB" . $match->cap1 . "C";
  });
}

# Replace global
{
  my $re = Regex->new("abc");
  my $string = "ppzabczabcz";
  
  # "ppzABCzABCz"
  my $result = $re->replace_g($string, "ABC");
}

# Replace global with a callback and capture
{
  my $re = Regex->new("a(bc)");
  my $string = "ppzabczabcz";
  
  # "ppzABCbcPQRSzABCbcPQRSz"
  my $result = $re->replace_g($string, method : string ($re : Regex, $match : Regex::Match) {
    return "ABC" . $match->cap1 . "PQRS";
  });
}

# . - single line mode
{
  my $re = Regex->new("(.+)", "s");
  my $string = "abc\ndef";
  
  my $match = $re->match($string);
  
  unless ($match) {
    return 0;
  }
  
  unless ($match->cap1 eq "abc\ndef") {
    return 0;
  }
}

Dependent Resources

SPVM::Resource::RE2

Regular Expression Syntax

Google RE2 Syntax

Fields

captures

has captures : ro string[];

The captured strings.

This field is deprecated and will be removed.

match_start

has match_start : ro int;

The start offset of the matched string.

This field is deprecated and will be removed.

match_length

has match_length : ro int;

The length of the matched string.

This field is deprecated and will be removed.

replaced_count

has replaced_count : ro int;

The replaced count.

This field is deprecated and will be removed.

Class Methods

new

static method new : Regex ($pattern : string, $flags : string = undef)

Creates a new Regex object and compiles the regex pattern $pattern with the flags $flags, and retruns the created object.

my $re = Regex->new("^ab+c");
my $re = Regex->new("^ab+c", "s");

Instance Methods

match

method match : Regex::Match ($string : string, $offset : int = 0, $length : int = -1);

The alias for the following match_forward method.

my $ret = $self->match_forward($string, \$offset, $length);

match_forward

method match_forward : Regex::Match ($string : string, $offset_ref : int*, $length : int = -1);

Performs pattern matching on the substring from the offset $$offset_ref to the length $length of the string $string.

The $$offset_ref is updated to the next position.

If the pattern matching is successful, returns a Regex::Match object. Otherwise returns undef.

Exceptions:

The $string must be defined. Otherwise an exception is thrown.

The $offset + the $length must be less than or equal to the length of the $string. Otherwise an exception is thrown.

If the regex is not compiled, an exception is thrown.

replace

method replace  : string ($string : string, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef)

The alias for the following replace_common method.

my $ret = $self->replace_common($string, $replace, \$offset, $length, $options);

replace_g

method replace_g  : string ($string : string, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef)

The alias for the following replace_common method.

unless ($options) {
  $options = {};
}
$options = Fn->merge_options({global => 1}, $options);
return $self->replace_common($string, $replace, \$offset, $length, $options);

replace_common

method replace_common : string ($string : string, $replace : object of string|Regex::Replacer,
  $offset_ref : int*, $length : int = -1, $options : object[] = undef);

Replaces the substring from the offset $$offset_ref to the length $length of the string $string with the replacement string or callback $replace with the options $options.

If the $replace is a Regex::Replacer object, the return value of the callback is used for the replacement.

Options:

global

This option must be a Int object. Otherwise an exception is thrown.

If the value of the Int object is a true value, the global replacement is performed.
info

This option must be an array of the Regex::ReplaceInfo object. Otherwise an exception is thrown.

If this option is specifed, the first element of the array is set to a Regex::ReplaceInfo object of the replacement result.

Exceptions:

The $string must be defined. Otherwise an exception is thrown.

The $replace must be a string or a Regex::Replacer object. Otherwise an exception is thrown.

The $offset must be greater than or equal to 0. Otherwise an exception is thrown.

The $offset + the $length must be less than or equal to the length of the $string. Otherwise an exception is thrown.

Exceptions of the match_forward method can be thrown.

split

method split : string[] ($string : string, $limit : int = 0);

The same as the split method in the Fn class, but the regular expression is used as the separator.

buffer_match

method buffer_match : Regex::Match ($string_buffer : StringBuffer, $offset : int = 0, $length : int = -1);

The same as "match", but the first argument is a StringBuffer object, and the following excetpions are thrown.

Exceptions:

The $offset + $length must be less than or equalt to the lenght of the $string_buffer. Otherwise an exception is thrown.

buffer_match_forward

method buffer_match_forward : Regex::Match ($string_buffer : StringBuffer, $offset_ref : int*, $length : int = -1);

The same as "match_forward", but the first argument is a StringBuffer object, and the following excetpions are thrown.

Exceptions:

The $offset + $length must be less than or equalt to the lenght of the $string_buffer. Otherwise an exception is thrown.

buffer_replace

method buffer_replace  : void ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef);

The same as "replace", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.

buffer_replace_g

method buffer_replace_g  : string ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset : int = 0, $length : int = -1, $options : object[] = undef);

The same as "replace_g", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.

buffer_replace_common

method buffer_replace_common : void ($string_buffer : StringBuffer, $replace : object of string|Regex::Replacer, $offset_ref : int*, $length : int = -1, $options : object[] = undef);

The same as "replace_common", but the first argument is a StringBuffer object, and the return type is void.

The replacement is performed on the string buffer.