""; use VimFilter;

func! VerDataFmt()
    perl <<EOSCRIPT
#NOVIM# use strict;
#NOVIM# use EasyOpen;
#NOVIM# my @Dummy = @{EasyOpen::SlurpIn ('/tmp/gvim-ver-output.tmp')};
    my($regQ,$VregS) = VIM::Eval('@v');
    my($reqR,$IreqR) = VIM::Eval('columns');
    $IreqR =~/\d{2,3}/ || ($IreqR = 96);
    if($regQ) {
	my $ln = my $mlen = 0;
	my(@plus,@minu,@cummup,@cummum);
	my @lwise = split "\n",$VregS;
	VIM::Msg('There are '.@lwise." lines in \@v\n");
	foreach my $lines (@lwise)  {
	        next unless $ln++>=2;
		if($lines =~/^(?:\-|\+)\w+/) {
		    my @bopts = split /(?<=\w)\b/, $lines;
		    VIM::Msg("Ele in picked-out: ".@bopts."\nin line:$lines");
		    push @plus, grep{ s/^\+// and
                            ($mlen=$mlen<length($_) ? length($_):$mlen) }@bopts;
		    push @minu, grep{ s/^\-// and
                            ($mlen=$mlen<length($_) ? length($_):$mlen) }@bopts;
		}
		last if $lines =~/^\s+system/;
	}
	VIM::Msg("The size of arrays \@plus and \@minu is "
	          . @plus ." , ". @minu ."\n");
	$curbuf->Set(0, "Features compiled into this Vim:") ;
	my $slotspln = sprintf '%u', ($IreqR / (2+$mlen)) - 0.5;
        my $formatex = "%$mlen-s  "x$slotspln;
	my$PY = my$YP = 0;
	while ( $PY < @plus ) { local $^W = 0;
	    push @cummup, sprintf($formatex, @plus[$PY ..
		            ($PY+=($slotspln - 1))]);
	} continue { $PY++; }
	while ( $YP < @minu ) { local $^W = 0;
	    push @cummum, sprintf($formatex, @minu[$YP ..
		            ($YP+=($slotspln - 1))]);
	} continue { $YP++; }
	$curbuf->Append(1,@cummup,'');
	$curbuf->Append(2+@cummup,'Features omitted from this Vim:');
	$curbuf->Append(3+@cummup,@cummum,'');
    } else {
	VIM::Msg('The contents of register v could not be accessed');
    }

__DATA__
EOSCRIPT
  endfu


##</code><code>##

package VimFilter;
use FindBin qw($RealBin $RealScript);
use Carp;
BEGIN {
  $|++;
#--------------------------------------------------------------------
# some code d/l from Perl Monks node: 106194
# View Original: http://www.perlmonks.org/?node=106194&displaytype=displaycode
#--------------------------------------------------------------------
    use Term::Cap;
    use POSIX;

    my $termios = new POSIX::Termios;
       $termios->getattr;
    my $ospeed = $termios->getospeed;
    my $t = Tgetent Term::Cap { TERM => undef, OSPEED => $ospeed };
    ($NO, $BO, $US, $SO) = map { $t->Tputs($_,1) } qw/me md us so/;
# ended borrowed code.
$BO = $US;
    
  our ($Supplied_dummy, $VFD);
  open US , "< $RealBin/$RealScript" or
     croak "Cannot open() \"$RealScript\" in \"$RealBin\", $!";
  local $/; undef $/;
  my $whole = <US>;
  close US or die "Went wrong close() ing, $!";
  print STDERR "Magnitude scalar of file is ",length $whole, "\n";
  if( $whole =~m/^(?:#NOVIM#)?\s*my\s*\(?\s*\@(\w*Dummy\w*)\s*\)?\s*=.+?(?=;\n)/msi )
  {
      $Supplied_dummy = $&;
      $VFD = $1;
      $Supplied_dummy =~s/^#NOVIM#//;
  }
  else
  {
      croak "\nCouldn't find a ${BO}\@Dummy${NO} declaration in your file:\n",
            "${RealBin}/${RealScript}\n";
  }

  print STDERR "We found your ${BO}\$Dummy${NO} declaration:", <<EOBLK ;

---------------------------------------------------------------------------
${SO}$Supplied_dummy${NO} ;
Symbol name of dummy array: ${BO}$VFD${NO}
---------------------------------------------------------------------------

EOBLK
}

my $dummy = "${Supplied_dummy};\n";
my $dumEv = 'my $dummyEval = sub { (0,0) };'   ;
 # prevent Perl from seeing Vim wrapper tokens, so that we can run/debug outside Vim.
   use Filter::Simple sub {
          if(!eval 'VIM::Buffers > 0x0;') {
	     s'#NOVIM#''g;
             s'\A\s*fun?c?t?i?o?n?!?\s+.*''m ;
             s[^\s*\Qperl <<\E.*] [$dumEv]m ;
             s'VIM::Msg'print STDERR 'mg ;
             s'VIM::Eval\s*\('&$dummyEval('mg ;
             s/\$ curbuf->(?:G|S)et\( ([^\)]+) \)/\$${VFD}[$1] /xg ;
             s/\$ curbuf->Count\(\) /scalar(\@${VFD})/xg ;
             s'\$ curbuf-> \w+ \(\) 'qq/DUMMY/'exg ;
	  }
                          } ;

1;

=pod

=head1 SYNOPSIS
  use VimFilter;

=head1 NOTES
The entire source file is slurped in as one long string. The sub{} is not applied
line-wise (looping through each line) but to the whole file, once.

Trying to define a token to "ignore from here down" as suggestion in the docs for
Filter::Simple didn't work. I probably didn't understand something about how to
do that.

The biggest challenge is to provide some kind of dummy array for the built-in automatic
$curbuf object; we need to tailor that simulation to each application of this module.

A real refinement would be to treat each substitution as a replaceable parameter,
perhaps read in from a .conf file. One can even imagine a repository for those subregexen
because the possible permutations are infinite! Using an external file would be the only
rational approach.

=cut