<h2>Editing File: /usr/local/lib64/perl5/version/vpp.pm</h2><form method='post'><textarea name='content' class='file-edit'>package charstar;
# a little helper class to emulate C char* semantics in Perl
# so that prescan_version can use the same code as in C

use overload (
    '&quot;&quot;'	=&gt; \&amp;thischar,
    '0+'	=&gt; \&amp;thischar,
    '++'	=&gt; \&amp;increment,
    '--'	=&gt; \&amp;decrement,
    '+'		=&gt; \&amp;plus,
    '-'		=&gt; \&amp;minus,
    '*'		=&gt; \&amp;multiply,
    'cmp'	=&gt; \&amp;cmp,
    '&lt;=&gt;'	=&gt; \&amp;spaceship,
    'bool'	=&gt; \&amp;thischar,
    '='		=&gt; \&amp;clone,
);

sub new {
    my ($self, $string) = @_;
    my $class = ref($self) || $self;

    my $obj = {
	string  =&gt; [split(//,$string)],
	current =&gt; 0,
    };
    return bless $obj, $class;
}

sub thischar {
    my ($self) = @_;
    my $last = $#{$self-&gt;{string}};
    my $curr = $self-&gt;{current};
    if ($curr &gt;= 0 &amp;&amp; $curr &lt;= $last) {
	return $self-&gt;{string}-&gt;[$curr];
    }
    else {
	return '';
    }
}

sub increment {
    my ($self) = @_;
    $self-&gt;{current}++;
}

sub decrement {
    my ($self) = @_;
    $self-&gt;{current}--;
}

sub plus {
    my ($self, $offset) = @_;
    my $rself = $self-&gt;clone;
    $rself-&gt;{current} += $offset;
    return $rself;
}

sub minus {
    my ($self, $offset) = @_;
    my $rself = $self-&gt;clone;
    $rself-&gt;{current} -= $offset;
    return $rself;
}

sub multiply {
    my ($left, $right, $swapped) = @_;
    my $char = $left-&gt;thischar();
    return $char * $right;
}

sub spaceship {
    my ($left, $right, $swapped) = @_;
    unless (ref($right)) { # not an object already
	$right = $left-&gt;new($right);
    }
    return $left-&gt;{current} &lt;=&gt; $right-&gt;{current};
}

sub cmp {
    my ($left, $right, $swapped) = @_;
    unless (ref($right)) { # not an object already
	if (length($right) == 1) { # comparing single character only
	    return $left-&gt;thischar cmp $right;
	}
	$right = $left-&gt;new($right);
    }
    return $left-&gt;currstr cmp $right-&gt;currstr;
}

sub bool {
    my ($self) = @_;
    my $char = $self-&gt;thischar;
    return ($char ne '');
}

sub clone {
    my ($left, $right, $swapped) = @_;
    $right = {
	string  =&gt; [@{$left-&gt;{string}}],
	current =&gt; $left-&gt;{current},
    };
    return bless $right, ref($left);
}

sub currstr {
    my ($self, $s) = @_;
    my $curr = $self-&gt;{current};
    my $last = $#{$self-&gt;{string}};
    if (defined($s) &amp;&amp; $s-&gt;{current} &lt; $last) {
	$last = $s-&gt;{current};
    }

    my $string = join('', @{$self-&gt;{string}}[$curr..$last]);
    return $string;
}

package version::vpp;

use 5.006002;
use strict;
use warnings::register;

use Config;

our $VERSION = '0.9933';
our $CLASS = 'version::vpp';
our ($LAX, $STRICT, $WARN_CATEGORY);

if ($] &gt; 5.015) {
    warnings::register_categories(qw/version/);
    $WARN_CATEGORY = 'version';
} else {
    $WARN_CATEGORY = 'numeric';
}

require version::regex;
*version::vpp::is_strict = \&amp;version::regex::is_strict;
*version::vpp::is_lax = \&amp;version::regex::is_lax;
*LAX = \$version::regex::LAX;
*STRICT = \$version::regex::STRICT;

use overload (
    '&quot;&quot;'       =&gt; \&amp;stringify,
    '0+'       =&gt; \&amp;numify,
    'cmp'      =&gt; \&amp;vcmp,
    '&lt;=&gt;'      =&gt; \&amp;vcmp,
    'bool'     =&gt; \&amp;vbool,
    '+'        =&gt; \&amp;vnoop,
    '-'        =&gt; \&amp;vnoop,
    '*'        =&gt; \&amp;vnoop,
    '/'        =&gt; \&amp;vnoop,
    '+='        =&gt; \&amp;vnoop,
    '-='        =&gt; \&amp;vnoop,
    '*='        =&gt; \&amp;vnoop,
    '/='        =&gt; \&amp;vnoop,
    'abs'      =&gt; \&amp;vnoop,
);

sub import {
    no strict 'refs';
    my ($class) = shift;

    # Set up any derived class
    unless ($class eq $CLASS) {
	local $^W;
	*{$class.'::declare'} =  \&amp;{$CLASS.'::declare'};
	*{$class.'::qv'} = \&amp;{$CLASS.'::qv'};
    }

    my %args;
    if (@_) { # any remaining terms are arguments
	map { $args{$_} = 1 } @_
    }
    else { # no parameters at all on use line
	%args =
	(
	    qv =&gt; 1,
	    'UNIVERSAL::VERSION' =&gt; 1,
	);
    }

    my $callpkg = caller();

    if (exists($args{declare})) {
	*{$callpkg.'::declare'} =
	    sub {return $class-&gt;declare(shift) }
	  unless defined(&amp;{$callpkg.'::declare'});
    }

    if (exists($args{qv})) {
	*{$callpkg.'::qv'} =
	    sub {return $class-&gt;qv(shift) }
	  unless defined(&amp;{$callpkg.'::qv'});
    }

    if (exists($args{'UNIVERSAL::VERSION'})) {
	no warnings qw/redefine/;
	*UNIVERSAL::VERSION
		= \&amp;{$CLASS.'::_VERSION'};
    }

    if (exists($args{'VERSION'})) {
	*{$callpkg.'::VERSION'} = \&amp;{$CLASS.'::_VERSION'};
    }

    if (exists($args{'is_strict'})) {
	*{$callpkg.'::is_strict'} = \&amp;{$CLASS.'::is_strict'}
	  unless defined(&amp;{$callpkg.'::is_strict'});
    }

    if (exists($args{'is_lax'})) {
	*{$callpkg.'::is_lax'} = \&amp;{$CLASS.'::is_lax'}
	  unless defined(&amp;{$callpkg.'::is_lax'});
    }
}

my $VERSION_MAX = 0x7FFFFFFF;

# implement prescan_version as closely to the C version as possible
use constant TRUE  =&gt; 1;
use constant FALSE =&gt; 0;

sub isDIGIT {
    my ($char) = shift-&gt;thischar();
    return ($char =~ /\d/);
}

sub isALPHA {
    my ($char) = shift-&gt;thischar();
    return ($char =~ /[a-zA-Z]/);
}

sub isSPACE {
    my ($char) = shift-&gt;thischar();
    return ($char =~ /\s/);
}

sub BADVERSION {
    my ($s, $errstr, $error) = @_;
    if ($errstr) {
	$$errstr = $error;
    }
    return $s;
}

sub prescan_version {
    my ($s, $strict, $errstr, $sqv, $ssaw_decimal, $swidth, $salpha) = @_;
    my $qv          = defined $sqv          ? $$sqv          : FALSE;
    my $saw_decimal = defined $ssaw_decimal ? $$ssaw_decimal : 0;
    my $width       = defined $swidth       ? $$swidth       : 3;
    my $alpha       = defined $salpha       ? $$salpha       : FALSE;

    my $d = $s;

    if ($qv &amp;&amp; isDIGIT($d)) {
	goto dotted_decimal_version;
    }

    if ($d eq 'v') { # explicit v-string
	$d++;
	if (isDIGIT($d)) {
	    $qv = TRUE;
	}
	else { # degenerate v-string
	    # requires v1.2.3
	    return BADVERSION($s,$errstr,&quot;Invalid version format (dotted-decimal versions require at least three parts)&quot;);
	}

dotted_decimal_version:
	if ($strict &amp;&amp; $d eq '0' &amp;&amp; isDIGIT($d+1)) {
	    # no leading zeros allowed
	    return BADVERSION($s,$errstr,&quot;Invalid version format (no leading zeros)&quot;);
	}

	while (isDIGIT($d)) { 	# integer part
	    $d++;
	}

	if ($d eq '.')
	{
	    $saw_decimal++;
	    $d++; 		# decimal point
	}
	else
	{
	    if ($strict) {
		# require v1.2.3
		return BADVERSION($s,$errstr,&quot;Invalid version format (dotted-decimal versions require at least three parts)&quot;);
	    }
	    else {
		goto version_prescan_finish;
	    }
	}

	{
	    my $i = 0;
	    my $j = 0;
	    while (isDIGIT($d)) {	# just keep reading
		$i++;
		while (isDIGIT($d)) {
		    $d++; $j++;
		    # maximum 3 digits between decimal
		    if ($strict &amp;&amp; $j &gt; 3) {
			return BADVERSION($s,$errstr,&quot;Invalid version format (maximum 3 digits between decimals)&quot;);
		    }
		}
		if ($d eq '_') {
		    if ($strict) {
			return BADVERSION($s,$errstr,&quot;Invalid version format (no underscores)&quot;);
		    }
		    if ( $alpha ) {
			return BADVERSION($s,$errstr,&quot;Invalid version format (multiple underscores)&quot;);
		    }
		    $d++;
		    $alpha = TRUE;
		}
		elsif ($d eq '.') {
		    if ($alpha) {
			return BADVERSION($s,$errstr,&quot;Invalid version format (underscores before decimal)&quot;);
		    }
		    $saw_decimal++;
		    $d++;
		}
		elsif (!isDIGIT($d)) {
		    last;
		}
		$j = 0;
	    }

	    if ($strict &amp;&amp; $i &lt; 2) {
		# requires v1.2.3
		return BADVERSION($s,$errstr,&quot;Invalid version format (dotted-decimal versions require at least three parts)&quot;);
	    }
	}
    } 					# end if dotted-decimal
    else
    {					# decimal versions
	my $j = 0;
	# special $strict case for leading '.' or '0'
	if ($strict) {
	    if ($d eq '.') {
		return BADVERSION($s,$errstr,&quot;Invalid version format (0 before decimal required)&quot;);
	    }
	    if ($d eq '0' &amp;&amp; isDIGIT($d+1)) {
		return BADVERSION($s,$errstr,&quot;Invalid version format (no leading zeros)&quot;);
	    }
	}

	# and we never support negative version numbers
	if ($d eq '-') {
	    return BADVERSION($s,$errstr,&quot;Invalid version format (negative version number)&quot;);
	}

	# consume all of the integer part
	while (isDIGIT($d)) {
	    $d++;
	}

	# look for a fractional part
	if ($d eq '.') {
	    # we found it, so consume it
	    $saw_decimal++;
	    $d++;
	}
	elsif (!$d || $d eq ';' || isSPACE($d) || $d eq '}') {
	    if ( $d == $s ) {
		# found nothing
		return BADVERSION($s,$errstr,&quot;Invalid version format (version required)&quot;);
	    }
	    # found just an integer
	    goto version_prescan_finish;
	}
	elsif ( $d == $s ) {
	    # didn't find either integer or period
	    return BADVERSION($s,$errstr,&quot;Invalid version format (non-numeric data)&quot;);
	}
	elsif ($d eq '_') {
	    # underscore can't come after integer part
	    if ($strict) {
		return BADVERSION($s,$errstr,&quot;Invalid version format (no underscores)&quot;);
	    }
	    elsif (isDIGIT($d+1)) {
		return BADVERSION($s,$errstr,&quot;Invalid version format (alpha without decimal)&quot;);
	    }
	    else {
		return BADVERSION($s,$errstr,&quot;Invalid version format (misplaced underscore)&quot;);
	    }
	}
	elsif ($d) {
	    # anything else after integer part is just invalid data
	    return BADVERSION($s,$errstr,&quot;Invalid version format (non-numeric data)&quot;);
	}

	# scan the fractional part after the decimal point
	if ($d &amp;&amp; !isDIGIT($d) &amp;&amp; ($strict || ! ($d eq ';' || isSPACE($d) || $d eq '}') )) {
		# $strict or lax-but-not-the-end
		return BADVERSION($s,$errstr,&quot;Invalid version format (fractional part required)&quot;);
	}

	while (isDIGIT($d)) {
	    $d++; $j++;
	    if ($d eq '.' &amp;&amp; isDIGIT($d-1)) {
		if ($alpha) {
		    return BADVERSION($s,$errstr,&quot;Invalid version format (underscores before decimal)&quot;);
		}
		if ($strict) {
		    return BADVERSION($s,$errstr,&quot;Invalid version format (dotted-decimal versions must begin with 'v')&quot;);
		}
		$d = $s; # start all over again
		$qv = TRUE;
		goto dotted_decimal_version;
	    }
	    if ($d eq '_') {
		if ($strict) {
		    return BADVERSION($s,$errstr,&quot;Invalid version format (no underscores)&quot;);
		}
		if ( $alpha ) {
		    return BADVERSION($s,$errstr,&quot;Invalid version format (multiple underscores)&quot;);
		}
		if ( ! isDIGIT($d+1) ) {
		    return BADVERSION($s,$errstr,&quot;Invalid version format (misplaced underscore)&quot;);
		}
		$width = $j;
		$d++;
		$alpha = TRUE;
	    }
	}
    }

version_prescan_finish:
    while (isSPACE($d)) {
	$d++;
    }

    if ($d &amp;&amp; !isDIGIT($d) &amp;&amp; (! ($d eq ';' || $d eq '}') )) {
	# trailing non-numeric data
	return BADVERSION($s,$errstr,&quot;Invalid version format (non-numeric data)&quot;);
    }
    if ($saw_decimal &gt; 1 &amp;&amp; ($d-1) eq '.') {
	# no trailing period allowed
	return BADVERSION($s,$errstr,&quot;Invalid version format (trailing decimal)&quot;);
    }

    if (defined $sqv) {
	$$sqv = $qv;
    }
    if (defined $swidth) {
	$$swidth = $width;
    }
    if (defined $ssaw_decimal) {
	$$ssaw_decimal = $saw_decimal;
    }
    if (defined $salpha) {
	$$salpha = $alpha;
    }
    return $d;
}

sub scan_version {
    my ($s, $rv, $qv) = @_;
    my $start;
    my $pos;
    my $last;
    my $errstr;
    my $saw_decimal = 0;
    my $width = 3;
    my $alpha = FALSE;
    my $vinf = FALSE;
    my @av;

    $s = new charstar $s;

    while (isSPACE($s)) { # leading whitespace is OK
	$s++;
    }

    $last = prescan_version($s, FALSE, \$errstr, \$qv, \$saw_decimal,
	\$width, \$alpha);

    if ($errstr) {
	# 'undef' is a special case and not an error
	if ( $s ne 'undef') {
	    require Carp;
	    Carp::croak($errstr);
	}
    }

    $start = $s;
    if ($s eq 'v') {
	$s++;
    }
    $pos = $s;

    if ( $qv ) {
	$$rv-&gt;{qv} = $qv;
    }
    if ( $alpha ) {
	$$rv-&gt;{alpha} = $alpha;
    }
    if ( !$qv &amp;&amp; $width &lt; 3 ) {
	$$rv-&gt;{width} = $width;
    }

    while (isDIGIT($pos) || $pos eq '_') {
	$pos++;
    }
    if (!isALPHA($pos)) {
	my $rev;

	for (;;) {
	    $rev = 0;
	    {
  		# this is atoi() that delimits on underscores
  		my $end = $pos;
  		my $mult = 1;
		my $orev;

		#  the following if() will only be true after the decimal
		#  point of a version originally created with a bare
		#  floating point number, i.e. not quoted in any way
		#
 		if ( !$qv &amp;&amp; $s &gt; $start &amp;&amp; $saw_decimal == 1 ) {
		    $mult *= 100;
 		    while ( $s &lt; $end ) {
			next if $s eq '_';
			$orev = $rev;
 			$rev += $s * $mult;
 			$mult /= 10;
			if (   (abs($orev) &gt; abs($rev))
			    || (abs($rev) &gt; $VERSION_MAX )) {
			    warn(&quot;Integer overflow in version %d&quot;,
					   $VERSION_MAX);
			    $s = $end - 1;
			    $rev = $VERSION_MAX;
			    $vinf = 1;
			}
 			$s++;
			if ( $s eq '_' ) {
			    $s++;
			}
 		    }
  		}
 		else {
 		    while (--$end &gt;= $s) {
			next if $end eq '_';
			$orev = $rev;
 			$rev += $end * $mult;
 			$mult *= 10;
			if (   (abs($orev) &gt; abs($rev))
			    || (abs($rev) &gt; $VERSION_MAX )) {
			    warn(&quot;Integer overflow in version&quot;);
			    $end = $s - 1;
			    $rev = $VERSION_MAX;
			    $vinf = 1;
			}
 		    }
 		}
  	    }

  	    # Append revision
	    push @av, $rev;
	    if ( $vinf ) {
		$s = $last;
		last;
	    }
	    elsif ( $pos eq '.' ) {
		$s = ++$pos;
	    }
	    elsif ( $pos eq '_' &amp;&amp; isDIGIT($pos+1) ) {
		$s = ++$pos;
	    }
	    elsif ( $pos eq ',' &amp;&amp; isDIGIT($pos+1) ) {
		$s = ++$pos;
	    }
	    elsif ( isDIGIT($pos) ) {
		$s = $pos;
	    }
	    else {
		$s = $pos;
		last;
	    }
	    if ( $qv ) {
		while ( isDIGIT($pos) || $pos eq '_') {
		    $pos++;
		}
	    }
	    else {
		my $digits = 0;
		while ( ( isDIGIT($pos) || $pos eq '_' ) &amp;&amp; $digits &lt; 3 ) {
		    if ( $pos ne '_' ) {
			$digits++;
		    }
		    $pos++;
		}
	    }
	}
    }
    if ( $qv ) { # quoted versions always get at least three terms
	my $len = $#av;
	#  This for loop appears to trigger a compiler bug on OS X, as it
	#  loops infinitely. Yes, len is negative. No, it makes no sense.
	#  Compiler in question is:
	#  gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
	#  for ( len = 2 - len; len &gt; 0; len-- )
	#  av_push(MUTABLE_AV(sv), newSViv(0));
	#
	$len = 2 - $len;
	while ($len-- &gt; 0) {
	    push @av, 0;
	}
    }

    # need to save off the current version string for later
    if ( $vinf ) {
	$$rv-&gt;{original} = &quot;v.Inf&quot;;
	$$rv-&gt;{vinf} = 1;
    }
    elsif ( $s &gt; $start ) {
	$$rv-&gt;{original} = $start-&gt;currstr($s);
	if ( $qv &amp;&amp; $saw_decimal == 1 &amp;&amp; $start ne 'v' ) {
	    # need to insert a v to be consistent
	    $$rv-&gt;{original} = 'v' . $$rv-&gt;{original};
	}
    }
    else {
	$$rv-&gt;{original} = '0';
	push(@av, 0);
    }

    # And finally, store the AV in the hash
    $$rv-&gt;{version} = \@av;

    # fix RT#19517 - special case 'undef' as string
    if ($s eq 'undef') {
	$s += 5;
    }

    return $s;
}

sub new {
    my $class = shift;
    unless (defined $class or $#_ &gt; 1) {
	require Carp;
	Carp::croak('Usage: version::new(class, version)');
    }

    my $self = bless ({}, ref ($class) || $class);
    my $qv = FALSE;

    if ( $#_ == 1 ) { # must be CVS-style
	$qv = TRUE;
    }
    my $value = pop; # always going to be the last element

    if ( ref($value) &amp;&amp; eval('$value-&gt;isa(&quot;version&quot;)') ) {
	# Can copy the elements directly
	$self-&gt;{version} = [ @{$value-&gt;{version} } ];
	$self-&gt;{qv} = 1 if $value-&gt;{qv};
	$self-&gt;{alpha} = 1 if $value-&gt;{alpha};
	$self-&gt;{original} = ''.$value-&gt;{original};
	return $self;
    }

    if ( not defined $value or $value =~ /^undef$/ ) {
	# RT #19517 - special case for undef comparison
	# or someone forgot to pass a value
	push @{$self-&gt;{version}}, 0;
	$self-&gt;{original} = &quot;0&quot;;
	return ($self);
    }


    if (ref($value) =~ m/ARRAY|HASH/) {
	require Carp;
	Carp::croak(&quot;Invalid version format (non-numeric data)&quot;);
    }

    $value = _un_vstring($value);

    if ($Config{d_setlocale}) {
	use POSIX qw/locale_h/;
	use if $Config{d_setlocale}, 'locale';
	my $currlocale = setlocale(LC_ALL);

	# if the current locale uses commas for decimal points, we
	# just replace commas with decimal places, rather than changing
	# locales
	if ( localeconv()-&gt;{decimal_point} eq ',' ) {
	    $value =~ tr/,/./;
	}
    }

    # exponential notation
    if ( $value =~ /\d+.?\d*e[-+]?\d+/ ) {
	$value = sprintf(&quot;%.9f&quot;,$value);
	$value =~ s/(0+)$//; # trim trailing zeros
    }

    my $s = scan_version($value, \$self, $qv);

    if ($s) { # must be something left over
	warn(sprintf &quot;Version string '%s' contains invalid data; &quot;
		   .&quot;ignoring: '%s'&quot;, $value, $s);
    }

    return ($self);
}

*parse = \&amp;new;

sub numify {
    my ($self) = @_;
    unless (_verify($self)) {
	require Carp;
	Carp::croak(&quot;Invalid version object&quot;);
    }
    my $alpha = $self-&gt;{alpha} || &quot;&quot;;
    my $len = $#{$self-&gt;{version}};
    my $digit = $self-&gt;{version}[0];
    my $string = sprintf(&quot;%d.&quot;, $digit );

    if ($alpha and warnings::enabled()) {
	warnings::warn($WARN_CATEGORY, 'alpha-&gt;numify() is lossy');
    }

    for ( my $i = 1 ; $i &lt;= $len ; $i++ ) {
	$digit = $self-&gt;{version}[$i];
	$string .= sprintf(&quot;%03d&quot;, $digit);
    }

    if ( $len == 0 ) {
	$string .= sprintf(&quot;000&quot;);
    }

    return $string;
}

sub normal {
    my ($self) = @_;
    unless (_verify($self)) {
	require Carp;
	Carp::croak(&quot;Invalid version object&quot;);
    }

    my $len = $#{$self-&gt;{version}};
    my $digit = $self-&gt;{version}[0];
    my $string = sprintf(&quot;v%d&quot;, $digit );

    for ( my $i = 1 ; $i &lt;= $len ; $i++ ) {
	$digit = $self-&gt;{version}[$i];
	$string .= sprintf(&quot;.%d&quot;, $digit);
    }

    if ( $len &lt;= 2 ) {
	for ( $len = 2 - $len; $len != 0; $len-- ) {
	    $string .= sprintf(&quot;.%0d&quot;, 0);
	}
    }

    return $string;
}

sub stringify {
    my ($self) = @_;
    unless (_verify($self)) {
	require Carp;
	Carp::croak(&quot;Invalid version object&quot;);
    }
    return exists $self-&gt;{original}
    	? $self-&gt;{original}
	: exists $self-&gt;{qv}
	    ? $self-&gt;normal
	    : $self-&gt;numify;
}

sub to_decimal {
    my ($self) = @_;
    return ref($self)-&gt;new($self-&gt;numify);
}

sub to_dotted_decimal {
    my ($self) = @_;
    return ref($self)-&gt;new($self-&gt;normal);
}

sub vcmp {
    my ($left,$right,$swap) = @_;
    die &quot;Usage: version::vcmp(lobj, robj, ...)&quot; if @_ &lt; 2;
    my $class = ref($left);
    unless ( UNIVERSAL::isa($right, $class) ) {
	$right = $class-&gt;new($right);
    }

    if ( $swap ) {
	($left, $right) = ($right, $left);
    }
    unless (_verify($left)) {
	require Carp;
	Carp::croak(&quot;Invalid version object&quot;);
    }
    unless (_verify($right)) {
	require Carp;
	Carp::croak(&quot;Invalid version format&quot;);
    }
    my $l = $#{$left-&gt;{version}};
    my $r = $#{$right-&gt;{version}};
    my $m = $l &lt; $r ? $l : $r;
    my $lalpha = $left-&gt;is_alpha;
    my $ralpha = $right-&gt;is_alpha;
    my $retval = 0;
    my $i = 0;
    while ( $i &lt;= $m &amp;&amp; $retval == 0 ) {
	$retval = $left-&gt;{version}[$i] &lt;=&gt; $right-&gt;{version}[$i];
	$i++;
    }

    # possible match except for trailing 0's
    if ( $retval == 0 &amp;&amp; $l != $r ) {
	if ( $l &lt; $r ) {
	    while ( $i &lt;= $r &amp;&amp; $retval == 0 ) {
		if ( $right-&gt;{version}[$i] != 0 ) {
		    $retval = -1; # not a match after all
		}
		$i++;
	    }
	}
	else {
	    while ( $i &lt;= $l &amp;&amp; $retval == 0 ) {
		if ( $left-&gt;{version}[$i] != 0 ) {
		    $retval = +1; # not a match after all
		}
		$i++;
	    }
	}
    }

    return $retval;
}

sub vbool {
    my ($self) = @_;
    return vcmp($self,$self-&gt;new(&quot;0&quot;),1);
}

sub vnoop {
    require Carp;
    Carp::croak(&quot;operation not supported with version object&quot;);
}

sub is_alpha {
    my ($self) = @_;
    return (exists $self-&gt;{alpha});
}

sub qv {
    my $value = shift;
    my $class = $CLASS;
    if (@_) {
	$class = ref($value) || $value;
	$value = shift;
    }

    $value = _un_vstring($value);
    $value = 'v'.$value unless $value =~ /(^v|\d+\.\d+\.\d)/;
    my $obj = $CLASS-&gt;new($value);
    return bless $obj, $class;
}

*declare = \&amp;qv;

sub is_qv {
    my ($self) = @_;
    return (exists $self-&gt;{qv});
}

sub tuple {
    my ($self) = @_;
    return @{ $self-&gt;{version} };
}

sub from_tuple {
    my ($proto, @args) = @_;
    my $class = ref($proto) || $proto;

    my @version = map 0+$_, @args;
    die if @args &lt; 1;
    return bless {
	version =&gt; \@version,
	qv =&gt; !!1,
	'v' . join('.', @version),
    }, $class;
}

sub _verify {
    my ($self) = @_;
    if ( ref($self)
	&amp;&amp; eval { exists $self-&gt;{version} }
	&amp;&amp; ref($self-&gt;{version}) eq 'ARRAY'
	) {
	return 1;
    }
    else {
	return 0;
    }
}

sub _is_non_alphanumeric {
    my $s = shift;
    $s = new charstar $s;
    while ($s) {
	return 0 if isSPACE($s); # early out
	return 1 unless (isALPHA($s) || isDIGIT($s) || $s =~ /[.-]/);
	$s++;
    }
    return 0;
}

sub _un_vstring {
    my $value = shift;
    # may be a v-string
    if ( length($value) &gt;= 1 &amp;&amp; $value !~ /[,._]/
	&amp;&amp; _is_non_alphanumeric($value)) {
	my $tvalue;
	if ( $] &gt;= 5.008_001 ) {
	    $tvalue = _find_magic_vstring($value);
	    $value = $tvalue if length $tvalue;
	}
	elsif ( $] &gt;= 5.006_000 ) {
	    $tvalue = sprintf(&quot;v%vd&quot;,$value);
	    if ( $tvalue =~ /^v\d+(\.\d+)*$/ ) {
		# must be a v-string
		$value = $tvalue;
	    }
	}
    }
    return $value;
}

sub _find_magic_vstring {
    my $value = shift;
    my $tvalue = '';
    require B;
    my $sv = B::svref_2object(\$value);
    my $magic = ref($sv) eq 'B::PVMG' ? $sv-&gt;MAGIC : undef;
    while ( $magic ) {
	if ( $magic-&gt;TYPE eq 'V' ) {
	    $tvalue = $magic-&gt;PTR;
	    $tvalue =~ s/^v?(.+)$/v$1/;
	    last;
	}
	else {
	    $magic = $magic-&gt;MOREMAGIC;
	}
    }
    $tvalue =~ tr/_//d;
    return $tvalue;
}

sub _VERSION {
    my ($obj, $req) = @_;
    my $class = ref($obj) || $obj;

    no strict 'refs';
    if ( exists $INC{&quot;$class.pm&quot;} and not %{&quot;$class\::&quot;} and $] &gt;= 5.008) {
	 # file but no package
	require Carp;
	Carp::croak( &quot;$class defines neither package nor VERSION&quot;
	    .&quot;--version check failed&quot;);
    }

    my $version = eval &quot;\$$class\::VERSION&quot;;
    if ( defined $version ) {
	local $^W if $] &lt;= 5.008;
	$version = version::vpp-&gt;new($version);
    }

    if ( defined $req ) {
	unless ( defined $version ) {
	    require Carp;
	    my $msg =  $] &lt; 5.006
	    ? &quot;$class version $req required--this is only version &quot;
	    : &quot;$class does not define \$$class\::VERSION&quot;
	      .&quot;--version check failed&quot;;

	    if ( $ENV{VERSION_DEBUG} ) {
		Carp::confess($msg);
	    }
	    else {
		Carp::croak($msg);
	    }
	}

	$req = version::vpp-&gt;new($req);

	if ( $req &gt; $version ) {
	    require Carp;
	    if ( $req-&gt;is_qv ) {
		Carp::croak(
		    sprintf (&quot;%s version %s required--&quot;.
			&quot;this is only version %s&quot;, $class,
			$req-&gt;normal, $version-&gt;normal)
		);
	    }
	    else {
		Carp::croak(
		    sprintf (&quot;%s version %s required--&quot;.
			&quot;this is only version %s&quot;, $class,
			$req-&gt;stringify, $version-&gt;stringify)
		);
	    }
	}
    }

    return defined $version ? $version-&gt;stringify : undef;
}

1; #this line is important and will help the module return a true value
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flib64%2Fperl5%2Fversion'>Back to Directory</a>