

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: vpp.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>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 (
    &#039;&quot;&quot;&#039;	=&gt; \&amp;thischar,
    &#039;0+&#039;	=&gt; \&amp;thischar,
    &#039;++&#039;	=&gt; \&amp;increment,
    &#039;--&#039;	=&gt; \&amp;decrement,
    &#039;+&#039;		=&gt; \&amp;plus,
    &#039;-&#039;		=&gt; \&amp;minus,
    &#039;*&#039;		=&gt; \&amp;multiply,
    &#039;cmp&#039;	=&gt; \&amp;cmp,
    &#039;&lt;=&gt;&#039;	=&gt; \&amp;spaceship,
    &#039;bool&#039;	=&gt; \&amp;thischar,
    &#039;=&#039;		=&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 &#039;&#039;;
    }
}

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 &#039;&#039;);
}

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(&#039;&#039;, @{$self-&gt;{string}}[$curr..$last]);
    return $string;
}

package version::vpp;

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

use Config;

our $VERSION = 0.9924;
our $CLASS = &#039;version::vpp&#039;;
our ($LAX, $STRICT, $WARN_CATEGORY);

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

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 (
    &#039;&quot;&quot;&#039;       =&gt; \&amp;stringify,
    &#039;0+&#039;       =&gt; \&amp;numify,
    &#039;cmp&#039;      =&gt; \&amp;vcmp,
    &#039;&lt;=&gt;&#039;      =&gt; \&amp;vcmp,
    &#039;bool&#039;     =&gt; \&amp;vbool,
    &#039;+&#039;        =&gt; \&amp;vnoop,
    &#039;-&#039;        =&gt; \&amp;vnoop,
    &#039;*&#039;        =&gt; \&amp;vnoop,
    &#039;/&#039;        =&gt; \&amp;vnoop,
    &#039;+=&#039;        =&gt; \&amp;vnoop,
    &#039;-=&#039;        =&gt; \&amp;vnoop,
    &#039;*=&#039;        =&gt; \&amp;vnoop,
    &#039;/=&#039;        =&gt; \&amp;vnoop,
    &#039;abs&#039;      =&gt; \&amp;vnoop,
);

sub import {
    no strict &#039;refs&#039;;
    my ($class) = shift;

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

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

    my $callpkg = caller();

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

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

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

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

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

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

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 &#039;v&#039;) { # 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 &#039;0&#039; &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 &#039;.&#039;)
	{
	    $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 &#039;_&#039;) {
		    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 &#039;.&#039;) {
		    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 &#039;.&#039; or &#039;0&#039;
	if ($strict) {
	    if ($d eq &#039;.&#039;) {
		return BADVERSION($s,$errstr,&quot;Invalid version format (0 before decimal required)&quot;);
	    }
	    if ($d eq &#039;0&#039; &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 &#039;-&#039;) {
	    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 &#039;.&#039;) {
	    # we found it, so consume it
	    $saw_decimal++;
	    $d++;
	}
	elsif (!$d || $d eq &#039;;&#039; || isSPACE($d) || $d eq &#039;}&#039;) {
	    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&#039;t find either integer or period
	    return BADVERSION($s,$errstr,&quot;Invalid version format (non-numeric data)&quot;);
	}
	elsif ($d eq &#039;_&#039;) {
	    # underscore can&#039;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 &#039;;&#039; || isSPACE($d) || $d eq &#039;}&#039;) )) {
		# $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 &#039;.&#039; &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 &#039;v&#039;)&quot;);
		}
		$d = $s; # start all over again
		$qv = TRUE;
		goto dotted_decimal_version;
	    }
	    if ($d eq &#039;_&#039;) {
		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 &#039;;&#039; || $d eq &#039;}&#039;) )) {
	# 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 &#039;.&#039;) {
	# 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) {
	# &#039;undef&#039; is a special case and not an error
	if ( $s ne &#039;undef&#039;) {
	    require Carp;
	    Carp::croak($errstr);
	}
    }

    $start = $s;
    if ($s eq &#039;v&#039;) {
	$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 &#039;_&#039;) {
	$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 &#039;_&#039;;
			$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 &#039;_&#039; ) {
			    $s++;
			}
 		    }
  		}
 		else {
 		    while (--$end &gt;= $s) {
			next if $end eq &#039;_&#039;;
			$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 &#039;.&#039; ) {
		$s = ++$pos;
	    }
	    elsif ( $pos eq &#039;_&#039; &amp;&amp; isDIGIT($pos+1) ) {
		$s = ++$pos;
	    }
	    elsif ( $pos eq &#039;,&#039; &amp;&amp; isDIGIT($pos+1) ) {
		$s = ++$pos;
	    }
	    elsif ( isDIGIT($pos) ) {
		$s = $pos;
	    }
	    else {
		$s = $pos;
		last;
	    }
	    if ( $qv ) {
		while ( isDIGIT($pos) || $pos eq &#039;_&#039;) {
		    $pos++;
		}
	    }
	    else {
		my $digits = 0;
		while ( ( isDIGIT($pos) || $pos eq &#039;_&#039; ) &amp;&amp; $digits &lt; 3 ) {
		    if ( $pos ne &#039;_&#039; ) {
			$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 &#039;v&#039; ) {
	    # need to insert a v to be consistent
	    $$rv-&gt;{original} = &#039;v&#039; . $$rv-&gt;{original};
	}
    }
    else {
	$$rv-&gt;{original} = &#039;0&#039;;
	push(@av, 0);
    }

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

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

    return $s;
}

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

    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(&#039;$value-&gt;isa(&quot;version&quot;)&#039;) ) {
	# 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} = &#039;&#039;.$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}, &#039;locale&#039;;
	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 &#039;,&#039; ) {
	    $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 &#039;%s&#039; contains invalid data; &quot;
		   .&quot;ignoring: &#039;%s&#039;&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, &#039;alpha-&gt;numify() is lossy&#039;);
    }

    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 vcmp {
    my ($left,$right,$swap) = @_;
    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&#039;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 = &#039;v&#039;.$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 _verify {
    my ($self) = @_;
    if ( ref($self)
	&amp;&amp; eval { exists $self-&gt;{version} }
	&amp;&amp; ref($self-&gt;{version}) eq &#039;ARRAY&#039;
	) {
	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 = &#039;&#039;;
    require B;
    my $sv = B::svref_2object(\$value);
    my $magic = ref($sv) eq &#039;B::PVMG&#039; ? $sv-&gt;MAGIC : undef;
    while ( $magic ) {
	if ( $magic-&gt;TYPE eq &#039;V&#039; ) {
	    $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 &#039;refs&#039;;
    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><br><input type='hidden' name='archivo_editar' value='/lib64/perl5/vendor_perl/version/vpp.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fperl5%2Fvendor_perl%2Fversion' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>