split

#!/usr/bin/perl

# $Id: split,v 1.16 2006-08-27 13:43:03 jonathan Exp $

# Written by Jonathan Ledlie
# jonathan@eecs.harvard.edu

use strict;
use POSIX qw(floor ceil);
use Getopt::Std;

my $usage = "Usage: split -k 'operators' [-z] filename\n";
$usage .=   "       cat filename | split -k 'operators'\n\n";
$usage .=   '\'operators\': e.g. $1 $4+$5+$6 7+5 $5>0'."\n";
$usage .=   "       -z convert any bad eval to 0 (default is to ignore the line)\n";
$usage .=   "       Operators may be boolean, in which case they are not printed\n";
$usage .=   "       -e call eval on every item (useful for e.g. floor(x*y))\n";
$usage .=   "       -q quiet mode";

#e.g. $1 $4+5 $2-$4 $4+$3*4

my $debug = 0;
my $opsLine = '';
my $zero = '';
my $ignoreLineCount = 0;
my $validLineCount = 0;
my $evalAll = 0;

my %para = ();
getopts('wk:zeq', \%para);

if (defined($para{'k'})) {
    $opsLine = $para{'k'};
} else {
    die ($usage);
}

if (defined($para{'e'})) {
    $evalAll = 1;
}

my $convertToZero = 0;
if (defined($para{'z'})) {
    $convertToZero = 1;
}

my @ops = split (/\s+/, $opsLine);

#see if this can be fast pathed
if ($#ops==0 && !&containsBoolean($ops[0]) &&
    !&containsMath($ops[0])) {
    if ($ops[0] =~ /\$(\d+)/) {
	if ($debug) {
	    warn "fast path\n";
	}
	#exit (0);
	my $item = $1;
	$item--;
	while (my $line = <>) {
	    my (@items) = split (/\s+/, $line);
	    #print "item = $item\n";
	    print "$items[$item]\n";   
	    #exit (0);
	}
    } else {
	die ("Problem with fast path\n");
    }
    exit (0);
}

while (my $line = <>) {
    $line =~ s/^\s+//;
    $line =~ s/\s+$//;
    my (@items) = split (/\s+/, $line);
    my $lineOK = 1;
    my $resLine = '';
    for (my $i = 0; $i <= $#ops; $i++) {

	my $isBoolean = 0;
	my $op = $ops[$i];

	# Could be done with this, but you would lose error checking
	# $op =~ s/(\d+)/$items[$1]/g;

	while ($lineOK && $op =~ /\$(\d+)/) {
	    my $column = $1;
	    if ($debug) {
		warn "column $column\n";
	    }
	    if (defined ($items[$column-1])) {
		if ($debug) {
		    warn "got col $column $items[$column-1]\n";
		}
		$op =~ s/\$$column/$items[$column-1]/;
#		print ("op $op\n");
	    } else {
		if ($debug) {
		    warn "no col $column\n";
		}
		#warn ("Line did not match: $line operator $ops[$i]\n");
		$lineOK = 0;
	    }
	}

	if ($debug) {
	    warn "op $op\n";
	}

	if (&containsBoolean($op)) {
	    if ($debug) {
		warn "contains bool $op\n";
	    }
	    #eval $op;
	    #warn (eval {$op});
	    #warn "op $op\n";
	    if (!(eval $op)) {
		if ($debug) {
		    warn "false\n";
		}
		if ($convertToZero) {
		    $op = 0;
		} else {
		    $lineOK = 0;
		}
	    } else {
		if ($debug) {
		    warn "true\n";
		}
	    }

	} else {
	    if (&containsMath($op)) {
		if ($debug) {
		    warn "contains math op $op\n";
		}
		$op = eval ($op);
		if ($op =~ /e/) {
		  my $math_op = sprintf ("%.3f",$op);
		  $op = $math_op;
		}
	    }
	    if ($i != 0) {
		$resLine .= ' ';
	    }
	    $resLine = $resLine . "$op";

	}
	if ($debug) {
	    warn "resLine $resLine\n";
	}

    }

    if ($lineOK) {
	#$resLine =~ s/^\s+//;
	print "$resLine\n";
	$validLineCount++;
    } else {
	$ignoreLineCount++;
	#warn "Ignoring: $line";
    }

    #print "done with line\n";
    #exit (0);

}

if ($ignoreLineCount > 0 && !defined($para{'q'})) {
    warn ("split ignored: $ignoreLineCount valid: $validLineCount lines\n");
}

sub containsBoolean {
    my ($val) = @_;
    if (($val =~ /==/) ||
	($val =~ /<=/) ||
	($val =~ />=/) ||
	($val =~ /</)  ||
	($val =~ />/)) {
	return 1;
    }
    return 0;
}


sub containsMath {
    my ($val) = @_;
    $val =~ s/^-//;

    #print "math?\n";

    if ($val =~ /[A-Za-z]/) {
	#print "no 1\n";
	return 0;
    }

    if (($val =~ /\d\+\d/) ||
	($val =~ /\d\-\d/) ||
	($val =~ /\d\*\d/) ||
	($val =~ /\d\/\d/)  ||
	($val =~ /\d\^\d/)) {
      #print "yes\n";
	return 1;
    }

    if (($val =~ /\+/) ||
	($val =~ /\-/) ||
	($val =~ /\*/) ||
	($val =~ /\//)  ||
	($val =~ /\^/)) {
      #print "yes\n";
	return 1;
    }

    #print "no 2\n";
    return 0;
}