File Coverage

blib/lib/re/engine/GNU.pm

Criterion	Covered	Total	%
statement	27	28	96.4
branch	5	10	50.0
condition	2	6	33.3
subroutine	8	8	100.0
pod			n/a
total	42	52	80.7

package re::engine::GNU;
use strict;
use warnings FATAL => 'all';
use 5.010000;
use XSLoader ();

# ABSTRACT: GNU Regular Expression Engine

our $AUTHORITY = 'cpan:JDDPAUSE'; # AUTHORITY

# All engines should subclass the core Regexp package
our @ISA = 'Regexp';

BEGIN {
    #
    our $VERSION = '0.027'; # VERSION
    #
    # Note that $VERSION is always defined when you use a distributed CPAN package.
    # With old versions of perl, only the XSLoader::load(__PACKAGE__, $version) works.
    # E.g. with perl-5.10, doing directly:
    # make test
    # within the repository may yell like this:
    # Error:  XSLoader::load('Your::Module', $Your::Module::VERSION)
    # In this case, you can put the module version in the RE_ENGINE_GNU_VERSION
    # environment variable, e.g.:
    # RE_ENGINE_GNU_VERSION=0.026 make test
    #
    my $version = eval q{$VERSION} // $ENV{RE_ENGINE_GNU_VERSION}; ## no critic
    defined($version) ? XSLoader::load(__PACKAGE__, $version) : XSLoader::load();
}

{
    no strict 'subs';                     ## no critic
    our $RE_SYNTAX_AWK                    = RE_SYNTAX_AWK;
    our $RE_SYNTAX_ED                     = RE_SYNTAX_ED;
    our $RE_SYNTAX_EGREP                  = RE_SYNTAX_EGREP;
    our $RE_SYNTAX_EMACS                  = RE_SYNTAX_EMACS;
    our $RE_SYNTAX_GNU_AWK                = RE_SYNTAX_GNU_AWK;
    our $RE_SYNTAX_GREP                   = RE_SYNTAX_GREP;
    our $RE_SYNTAX_POSIX_AWK              = RE_SYNTAX_POSIX_AWK;
    our $RE_SYNTAX_POSIX_BASIC            = RE_SYNTAX_POSIX_BASIC;
    our $RE_SYNTAX_POSIX_EGREP            = RE_SYNTAX_POSIX_EGREP;
    our $RE_SYNTAX_POSIX_EXTENDED         = RE_SYNTAX_POSIX_EXTENDED;
    our $RE_SYNTAX_POSIX_MINIMAL_BASIC    = RE_SYNTAX_POSIX_MINIMAL_BASIC;
    our $RE_SYNTAX_POSIX_MINIMAL_EXTENDED = RE_SYNTAX_POSIX_MINIMAL_EXTENDED;
    our $RE_SYNTAX_SED                    = RE_SYNTAX_SED;
    #
    # __USE_GNU specifics
    #
    our $RE_BACKSLASH_ESCAPE_IN_LISTS = RE_BACKSLASH_ESCAPE_IN_LISTS;
    our $RE_BK_PLUS_QM                = RE_BK_PLUS_QM;
    our $RE_CHAR_CLASSES              = RE_CHAR_CLASSES;
    our $RE_CONTEXT_INDEP_ANCHORS     = RE_CONTEXT_INDEP_ANCHORS;
    our $RE_CONTEXT_INDEP_OPS         = RE_CONTEXT_INDEP_OPS;
    our $RE_CONTEXT_INVALID_OPS       = RE_CONTEXT_INVALID_OPS;
    our $RE_DOT_NEWLINE               = RE_DOT_NEWLINE;
    our $RE_DOT_NOT_NULL              = RE_DOT_NOT_NULL;
    our $RE_HAT_LISTS_NOT_NEWLINE     = RE_HAT_LISTS_NOT_NEWLINE;
    our $RE_INTERVALS                 = RE_INTERVALS;
    our $RE_LIMITED_OPS               = RE_LIMITED_OPS;
    our $RE_NEWLINE_ALT               = RE_NEWLINE_ALT;
    our $RE_NO_BK_BRACES              = RE_NO_BK_BRACES;
    our $RE_NO_BK_PARENS              = RE_NO_BK_PARENS;
    our $RE_NO_BK_REFS                = RE_NO_BK_REFS;
    our $RE_NO_BK_VBAR                = RE_NO_BK_VBAR;
    our $RE_NO_EMPTY_RANGES           = RE_NO_EMPTY_RANGES;
    our $RE_UNMATCHED_RIGHT_PAREN_ORD = RE_UNMATCHED_RIGHT_PAREN_ORD;
    our $RE_NO_POSIX_BACKTRACKING     = RE_NO_POSIX_BACKTRACKING;
    our $RE_NO_GNU_OPS                = RE_NO_GNU_OPS;
    our $RE_DEBUG                     = RE_DEBUG;
    our $RE_INVALID_INTERVAL_ORD      = RE_INVALID_INTERVAL_ORD;
    our $RE_ICASE                     = RE_ICASE;
    our $RE_CARET_ANCHORS_HERE        = RE_CARET_ANCHORS_HERE;
    our $RE_CONTEXT_INVALID_DUP       = RE_CONTEXT_INVALID_DUP;
    our $RE_NO_SUB                    = RE_NO_SUB;
}

sub import {
    my $class = shift;

    $^H{regcomp} = ENGINE;

    if (@_) {
        my %args = @_;
        if ( exists $args{'-debug'} ) {
            $^H{ __PACKAGE__ . '/debug' } = $args{'-debug'};
        }
        if ( exists $args{'-syntax'} ) {
            $^H{ __PACKAGE__ . '/syntax' } = $args{'-syntax'};
        }
    }

}

sub unimport {
    my $class = shift;

    if ( exists( $^H{regcomp} ) && $^H{regcomp} == ENGINE ) {
        delete( $^H{regcomp} );
    }

}

1;

__END__