package feedgnuplot; # for the metacpan indexer

use strict;

use warnings;

use Getopt::Long;

use Time::HiRes qw( usleep gettimeofday tv_interval );

use IO::Handle;

use IO::Select;

use List::Util qw( first );

use List::MoreUtils 'any';

use Scalar::Util qw( looks_like_number );

use Text::ParseWords; # for shellwords

use Pod::Usage;

use Time::Piece;

my $VERSION = '1.55';

my %options;

interpretCommandline();

my @curves = ();

my %curveFromID = ();

my $haveNewData;

my $last_replot_time = [gettimeofday];

my $last_replot_is_from_timer = 1;

my $this_replot_is_from_timer;

sub getRangeSize

{

my ($id) = @_;

# I'd like to use //, but I guess some people are still on perl 5.8

return

exists $options{rangesize_hash}{$id} ?

$options{rangesize_hash}{$id} :

$options{rangesize_default};

}

sub interpretCommandline

{

# if I'm using a self-plotting data file with a #! line, then $ARGV[0] will contain ALL of the

# options and $ARGV[1] will contain the data file to plot. In this case I need to split $ARGV[0] so

# that GetOptions() can parse it correctly. On the other hand, if I'm plotting normally (not with

# #!) a file with spaces in the filename, I don't want to split the filename. Hopefully this logic

# takes care of both those cases.

if (exists $ARGV[0] && !-r $ARGV[0])

{

unshift @ARGV, shellwords shift @ARGV;

}

# everything off by default:

# do not stream in the data by default

# point plotting by default.

# no monotonicity checks by default

# normal histograms by default

$options{ maxcurves } = 100;

$options{ histstyle} = 'freq';

# Previously I was using 'legend=s%' and 'curvestyle=s%' for curve addressing. This had cleaner

# syntax, but disregarded the order of the given options. This resulted in arbitrarily ordered

# curves. I thus make parse these into lists, and then also make hashes, for later use

# needed for these to be parsed into an array-ref, these default to []

$options{legend} = [];

$options{curvestyle} = [];

$options{style} = [];

$options{every} = [];

$options{histogram} = [];

$options{x1y2} = [];

$options{x2y1} = [];

$options{x2y2} = [];

$options{extracmds} = [];

$options{set} = [];

$options{unset} = [];

$options{equation} = [];

$options{curvestyleall} = '';

$options{styleall} = '';

$options{with} = '';

$options{rangesize} = [];

$options{tuplesize} = [];

GetOptions(\%options, 'stream:s', 'domain!', 'dataid!', 'vnlog!', '3d!', 'colormap!', 'lines!', 'points!',

'circles', 'legend=s{2}', 'autolegend!', 'xlabel=s', 'x2label=s', 'ylabel=s', 'y2label=s', 'zlabel=s',

'title=s', 'xlen=f',

'xmin=s', 'xmax=s', 'x2min=s', 'x2max=s',

'ymin=f', 'ymax=f', 'y2min=f', 'y2max=f',

'zmin=f', 'zmax=f',

'x2=s@', 'y2=s@', 'x1y2=s@', 'x2y1=s@', 'x2y2=s@',

'style=s{2}', 'curvestyle=s{2}', 'curvestyleall=s', 'styleall=s', 'with=s', 'extracmds=s@', 'set=s@', 'unset=s@',

'every=s{2}', 'everyall=s',

'square!', 'square_xy!', 'square-xy!', 'squarexy!', 'hardcopy=s', 'maxcurves=i', 'monotonic!', 'timefmt=s',

'equation=s@',

'image=s',

'histogram=s@', 'binwidth=f', 'histstyle=s',

'terminal=s',

'rangesize=s{2}', 'rangesizeall=i',

'tuplesize=s{2}', 'tuplesizeall=i',

'extraValuesPerPoint=i', # deprecated and undocumented

'help', 'dump', 'exit', 'version',

'geometry=s') or exit 1;

# handle various cmdline-option errors

if ( $options{help} )

{

pod2usage( -exitval => 0,

-verbose => 1, # synopsis and args

-output => \*STDOUT );

}

if( $options{version} )

{

print "feedgnuplot version $VERSION\n";

exit 0;

}

# --style and --curvestyle are synonyms, as are --styleall and

# --curvestyleall, so fill that in

if( $options{styleall} )

{

if($options{curvestyleall} ) { $options{curvestyleall} .= " $options{styleall}"; }

else { $options{curvestyleall} = $options{styleall}; }

delete $options{styleall};

}

# various square-xy synonyms

$options{'square_xy'} = 1 if $options{'square-xy'} || $options{'squarexy'};

push @{$options{curvestyle}}, @{$options{style}};

delete $options{style};

if( $options{curvestyleall} && $options{with} )

{

print STDERR "--curvestyleall and --with are mutually exclusive. Please just use one.\n";

exit -1;

}

if( $options{with} )

{

$options{curvestyleall} = "with $options{with}";

delete $options{with};

}

if( $options{dataid} && $options{vnlog} )

{

print STDERR "--dataid and --vnlog are mutually exclusive. Please just use one.\n";

exit -1;

}

# expand options that are given as comma-separated lists

for my $listkey (qw(histogram x2 y2 x1y2 x2y1 x2y2))

{

@{$options{$listkey}} = map split('\s*,\s*', $_), @{$options{$listkey}}

if defined $options{$listkey};

}

for my $listkey (qw(curvestyle rangesize tuplesize every))

{

next unless defined $options{$listkey};

my @in = @{$options{$listkey}};

my $N = @in / 2;

my @out;

for my $i (0..$N-1)

{

my $key = $in[2*$i];

my $value = $in[2*$i + 1];

for my $key_new (split('\s*,\s*', $key))

{

push @out, $key_new, $value;

}

}

@{$options{$listkey}} = @out;

}

# handle x2 == x2y1 and y2 == x1y2

push @{$options{x2y1}}, @{$options{x2}} if defined $options{x2};

push @{$options{x1y2}}, @{$options{y2}} if defined $options{y2};

$options{x2} = [];

$options{y2} = [];

# convert all tuplesize business to rangesize

my $domainsize = $options{'3d'} ? 2 : 1;

if (defined $options{tuplesizeall})

{

if (defined $options{rangesizeall} )

{

print STDERR "Only one of --rangesizeall and --tuplesizeall may be given\n";

exit -1;

}

$options{rangesizeall} = $options{tuplesizeall} - $domainsize;

delete $options{tuplesizeall};

}

if (defined $options{tuplesize})

{

$options{rangesize} //= [];

my $N = @{$options{tuplesize}} / 2;

for my $i (0..$N-1)

{

$options{tuplesize}[2*$i + 1] -= $domainsize;

}

push @{$options{rangesize}}, @{$options{tuplesize}};

delete $options{tuplesize};

}

# If we're plotting histograms, then set the default histogram options for

# each histogram curve

#

# Apply this to plain (non-cumulative) histograms

if( !$options{curvestyleall} && $options{histstyle} =~ /freq|fnorm/ )

{

for my $hist_curve(@{$options{histogram}})

{

# If we don't specify any options specifically for this histogram, use

# the defaults: filled boxes with borders

if( !any { $options{curvestyle}[$_*2] eq $hist_curve } 0..(@{$options{curvestyle}}/2 - 1) )

{

push @{$options{curvestyle}}, ($hist_curve, 'with boxes fill solid border lt -1');

}

}

}

# --legend and --curvestyle options are conceptually hashes, but are parsed as

# arrays in order to preserve the ordering. I parse both of these into hashes

# because those are useful to have later. After this I can access individual

# legends with $options{legend_hash}{curveid}

for my $listkey (qw(legend curvestyle rangesize every))

{

$options{"${listkey}_hash"} = {};

my $n = scalar @{$options{$listkey}}/2;

foreach my $idx (0..$n-1)

{

$options{"${listkey}_hash"}{$options{$listkey}[$idx*2]} = $options{$listkey}[$idx*2 + 1];

}

}

if ( defined $options{hardcopy} && defined $options{stream} )

{

print STDERR "--stream doesn't make sense together with --hardcopy\n";

exit -1;

}

if ( defined $options{rangesizeall} && defined $options{extraValuesPerPoint} )

{

print STDERR "Only one of --rangesizeall and --extraValuesPerPoint may be given\n";

exit -1;

}

# I now set up the rangesize to always be

#

# $options{rangesize_hash}{$id} // $options{rangesize_default}

#

# which is available as getRangeSize($id)

if ( $options{rangesizeall} )

{

$options{rangesize_default} = $options{rangesizeall};

}

else

{

$options{rangesize_default} = 1;

$options{rangesize_default} += $options{extraValuesPerPoint} if ($options{extraValuesPerPoint});

$options{rangesize_default}++ if ($options{colormap});

$options{rangesize_default}++ if ($options{circles} );

}

# parse stream option. Allowed only numbers >= 0 or 'trigger'. After this code

# $options{stream} is

# -1 for triggered replotting

# >0 for timed replotting

# undef if not streaming

#

# Note that '0' is not allowed, so !$options{stream} will do the expected

# thing

if(defined $options{stream})

{

# if no streaming period is given, default to 1Hz.

$options{stream} = 1 if $options{stream} eq '';

if( !looks_like_number $options{stream} )

{

if($options{stream} eq 'trigger')

{

$options{stream} = 0;

}

else

{

print STDERR "--stream can only take in values >=0 or 'trigger'\n";

exit -1;

}

}

if ( $options{stream} == 0 )

{

$options{stream} = -1;

}

elsif ( $options{stream} <= 0)

{

print STDERR "--stream can only take in values >=0 or 'trigger'\n";

exit -1;

}

}

if ($options{colormap})

{

# colormap styles all curves with palette. Seems like there should be a way to do this with a

# global setting, but I can't get that to work

$options{curvestyleall} .= ' palette';

}

if ( defined $options{binwidth} && !@{$options{histogram}} )

{

print STDERR "--binwidth doesn't make sense without any histograms\n";

exit -1;

}

if ( $options{'3d'} )

{

if ( !$options{domain} )

{

print STDERR "--3d only makes sense with --domain\n";

exit -1;

}

if ( $options{timefmt} )

{

print STDERR "--3d makes no sense with --timefmt\n";

exit -1;

}

if ( defined $options{x2min} || defined $options{x2max} ||

defined $options{y2min} || defined $options{y2max} ||

@{$options{x1y2}} || @{$options{x2y1}} || @{$options{x2y2}} )

{

print STDERR "--3d does not make sense with --x2... or --y2...\n";

exit -1;

}

if ( defined $options{xlen} )

{

print STDERR "--3d does not make sense with --xlen\n";

exit -1;

}

if ( defined $options{monotonic} )

{

print STDERR "--3d does not make sense with --monotonic\n";

exit -1;

}

if ( @{$options{histogram}} )

{

print STDERR "--3d does not make sense with histograms\n";

exit -1;

}

if ( defined $options{circles} )

{

print STDERR "--3d does not make sense with circles (gnuplot doesn't support this)\n";

exit -1;

}

}

else

{

if ( $options{timefmt} && !$options{domain} && !@{$options{histogram}} )

{

print STDERR "--timefmt makes sense only with --domain or --histogram\n";

exit -1;

}

if(!$options{colormap})

{

if ( defined $options{zmin} || defined $options{zmax} || defined $options{zlabel} )

{

print STDERR "--zmin/zmax/zlabel only makes sense with --3d or --colormap\n";

exit -1;

}

}

if ( defined $options{square_xy} )

{

print STDERR "--square_xy only makes sense with --3d\n";

exit -1;

}

for my $hist_curve(@{$options{histogram}})

{

my $hist_dim = getRangeSize($hist_curve);

if( $hist_dim != 1 )

{

print STDERR "I only support 1D histograms, but curve '$hist_curve' has '$hist_dim'-D data\n";

exit -1;

}

}

}

if(defined $options{xlen} && !$options{stream} )

{

print STDERR "--xlen does not make sense without --stream\n";

exit -1;

}

if($options{stream} && defined $options{xlen} &&

( defined $options{xmin} || defined $options{xmax}) &&

!defined $options{histogram})

{

print STDERR "With --stream and --xlen the X bounds are set, so neither --xmin nor --xmax make sense\n";

exit -1;

}

# --xlen implies an order to the data, so I force monotonicity

$options{monotonic} = 1 if defined $options{xlen};

if( $options{histstyle} !~ /freq|cum|uniq|cnorm|fnorm/ )

{

print STDERR "unknown histstyle. Allowed are 'freq...', 'fnorm...', 'cum...', 'uniq...', 'cnorm...'\n";

exit -1;

}

# deal with timefmt

if ( $options{timefmt} )

{

# I need to compute a regex to match the time field and I need to count how

# many whilespace-separated fields there are.

# strip leading and trailing whitespace

$options{timefmt} =~ s/^\s*//;

$options{timefmt} =~ s/\s*$//;

my $Nfields = () = split /\s+/, $options{timefmt}, -1;

$options{timefmt_Ncols} = $Nfields;

# make sure --xlen is an integer. With a timefmt xlen goes through strptime

# and strftime, and those are integer-only

if( defined $options{xlen} )

{

if( $options{xlen} - int($options{xlen}) )

{

print STDERR "When streaming --xlen MUST be an integer. Rounding up to the nearest second\n";

$options{xlen} = 1 + int($options{xlen});

}

}

}

# deal with --image. I just fill in --equation, and reverse the y extents if

# none are explicitly given

if( defined $options{image} )

{

# images generally have the origin at the top-left instead of the

# bottom-left, so given nothing else, I flip the y axis

if( !defined $options{xmin} && !defined $options{xmax} &&

!defined $options{ymin} && !defined $options{ymax} &&

! any { /^ *xrange\b/ } @{$options{set}} &&

! any { /^ *yrange\b/ } @{$options{set}} )

{

push @{$options{set}}, "xrange [:] noextend";

push @{$options{set}}, "yrange [:] reverse noextend";

}

if ( ! -r $options{image} )

{

die "Couldn't read image '$options{image}'";

}

unshift @{$options{equation}}, qq{"$options{image}" binary filetype=auto flipy with rgbimage title "$options{image}"};

delete $options{image};

}

}

sub getGnuplotVersion

{

open(GNUPLOT_VERSION, 'gnuplot --version |') or die "Couldn't run gnuplot";

my ($gnuplotVersion) = <GNUPLOT_VERSION> =~ /gnuplot\s*(\d*\.\d*)/;

if (!$gnuplotVersion)

{

print STDERR "Couldn't find the version of gnuplot. Does it work? Trying anyway...\n";

$gnuplotVersion = 0;

}

close(GNUPLOT_VERSION);

return $gnuplotVersion;

}

sub sendRangeCommand

{

my ($name, $min, $max) = @_;

return unless defined $min || defined $max;

if( defined $min )

{ $min = "\"$min\""; }

else

{ $min = ''; }

if( defined $max )

{ $max = "\"$max\""; }

else

{ $max = ''; }

my $cmd = "set $name [$min:$max]\n";

print PIPE $cmd;

}

sub makeDomainNumeric

{

my ($domain0) = @_;

if ( $options{timefmt} )

{

my $timepiece = Time::Piece->strptime( $domain0, $options{timefmt} )

or die "Couldn't parse time format. String '$domain0' doesn't fit format '$options{timefmt}'";

return $timepiece->epoch();

}

return $domain0;

}

my $prev_timed_replot_time = [gettimeofday];

my $pipe_in;

my $selector;

my $line_number = 0;

my $is_stdin = !@ARGV; # read stdin only if no data files given on the cmdline

sub openNextFile

{

my $fd;

if($is_stdin)

{

$fd = IO::Handle->new();

$fd->fdopen(fileno(STDIN), "r") or die "Couldn't open STDIN";

}

else

{

my $filename = shift @ARGV;

$fd = IO::File->new($filename, "r") or die "Couldn't open file '$filename'";

}

my $selector = IO::Select->new( $fd );

return ($fd, $selector);

}

sub getNextLine

{

sub getline_internal

{

while(1)

{

my $line = $pipe_in->getline();

if( !$is_stdin && !defined $line && $pipe_in->eof() && @ARGV)

{

# I got to the end of one file, so open the next one (which I'm

# sure exists)

($pipe_in, $selector) = openNextFile();

next;

}

return $line;

}

}

if( !defined $pipe_in )

{

($pipe_in, $selector) = openNextFile();

}

while(1)

{

$this_replot_is_from_timer = undef;

# if we're not streaming, or we're doing triggered-only replotting, simply

# do a blocking read

if (! $options{stream} || $options{stream} < 0)

{

$line_number++;

return getline_internal();

}

my $now = [gettimeofday];

my $time_remaining = $options{stream} - tv_interval($prev_timed_replot_time, $now);

if ( $time_remaining < 0 )

{

$prev_timed_replot_time = $now;

$this_replot_is_from_timer = 1;

return 'replot';

}

if ($selector->can_read($time_remaining))

{

$line_number++;

return getline_internal();

}

}

}

sub mainThread

{

local *PIPE;

my $outputfile;

my $outputfileType;

if( defined $options{hardcopy})

{

$outputfile = $options{hardcopy};

if( $outputfile =~ /^[^|] # starts with anything other than |

\.(eps|ps|pdf|png|svg|gp)$/ix) # ends with a known extension

{

$outputfileType = lc $1;

}

my %terminalOpts =

( eps => 'postscript noenhanced solid color enhanced eps',

ps => 'postscript noenhanced solid color landscape 12',

pdf => 'pdfcairo noenhanced solid color font ",12" size 11in,8.5in',

png => 'png noenhanced size 1280,1024',

svg => 'svg noenhanced',

gp => 'gp');

if( !defined $options{terminal} &&

defined $outputfileType &&

$terminalOpts{$outputfileType} )

{

$options{terminal} = $terminalOpts{$outputfileType};

}

die "Asked to plot to file '$outputfile', but I don't know which terminal to use, and no --terminal given"

unless $options{terminal};

}

sub gpterminal

{

return defined $options{terminal} && $options{terminal} eq 'gp';

}

sub datadump_only

{

return

exists $options{dump} ||

gpterminal();

}

sub search_PATH

{

for my $pathdir (File::Spec->path())

{

my $gnuplot_execpath = File::Spec->catfile($pathdir, $_[0]);

return $gnuplot_execpath

if -x $gnuplot_execpath && ! -d $gnuplot_execpath;

}

return undef;

}

if(datadump_only())

{

if(gpterminal())

{

open PIPE, '>', $outputfile;

my $gnuplotpath = search_PATH('gnuplot');

if(!defined $gnuplotpath)

{

print STDERR "Couldn't find the gnuplot executable path. Creating .gp file still, but omitting #!. This will NOT be self-executable";

}

else

{

chmod 0755, $outputfile;

print PIPE "#!$gnuplotpath\n";

}

}

else

{

*PIPE = *STDOUT;

}

}

else

{

my $dopersist = '';

if ( getGnuplotVersion() >= 4.3 && # --persist not available before this

# --persist is needed for the "half-alive" state (see documentation for

# --exit). This state is only used with these options:

!$options{stream} && $options{exit}) {

$dopersist = '--persist';

}

# We trap SIGINT to kill the data input, but keep the plot up. see

# documentation for --exit

if ($options{stream} && !$options{exit})

{

$SIG{INT} = sub

{

print STDERR "$0 received SIGINT. Send again to quit\n";

$SIG{INT} = undef;

};

}

my $geometry = defined $options{geometry} ?

"-geometry $options{geometry}" : '';

open PIPE, "|gnuplot $geometry $dopersist" or die "Can't initialize gnuplot\n";

autoflush PIPE 1;

}

if(!gpterminal())

{

print PIPE "set terminal $options{terminal}\n" if $options{terminal};

print PIPE "set output \"$outputfile\"\n" if $outputfile;

}

# set up plotting style

my $style = '';

if($options{lines}) { $style .= 'lines';}

if($options{points}) { $style .= 'points';}

if($options{circles})

{

$options{curvestyleall} = "with circles $options{curvestyleall}";

}

print PIPE "set style data $style\n" if $style;

print PIPE "set grid\n";

print(PIPE "set xlabel \"$options{xlabel }\"\n") if defined $options{xlabel};

print(PIPE "set x2label \"$options{x2label}\"\n") if defined $options{x2label};

print(PIPE "set ylabel \"$options{ylabel }\"\n") if defined $options{ylabel};

print(PIPE "set y2label \"$options{y2label}\"\n") if defined $options{y2label};

print(PIPE "set zlabel \"$options{zlabel }\"\n") if defined $options{zlabel};

print(PIPE "set title \"$options{title }\"\n") if defined $options{title};

if($options{square})

{

# set a square aspect ratio. Gnuplot does this differently for 2D and 3D plots

if(! $options{'3d'})

{

print(PIPE "set size ratio -1\n");

}

else

{

print(PIPE "set view equal xyz\n");

}

}

if($options{square_xy})

{

print(PIPE "set view equal xy\n");

}

# For the specified values, set the legend entries to 'title "blah blah"'

if(@{$options{legend}})

{

# @{$options{legend}} is a list where consecutive pairs are (curveID,

# legend). I use $options{legend} here instead of $options{legend_hash}

# because I create a new curve when I see a new one, and the hash is

# unordered, thus messing up the ordering

my $n = scalar @{$options{legend}}/2;

foreach my $idx (0..$n-1)

{

setCurveLabel($options{legend}[$idx*2 ],

$options{legend}[$idx*2 + 1]);

}

}

# add the extra curve options

if(@{$options{curvestyle}})

{

# @{$options{curvestyle}} is a list where consecutive pairs are (curveID,

# style).

my $n = scalar @{$options{curvestyle}}/2;

foreach my $idx (0..$n-1)

{

addCurveOption($options{curvestyle}[$idx*2 ],

$options{curvestyle}[$idx*2 + 1]);

}

}

if(@{$options{every}})

{

# @{$options{every}} is a list where consecutive pairs are (curveID,

# every).

my $n = scalar @{$options{every}}/2;

foreach my $idx (0..$n-1)

{

addEveryOption($options{every}[$idx*2 ],

$options{every}[$idx*2 + 1]);

}

}

addCurveOption($_, 'axes x1y2') foreach (@{$options{x1y2}});

addCurveOption($_, 'axes x2y1') foreach (@{$options{x2y1}});

addCurveOption($_, 'axes x2y2') foreach (@{$options{x2y2}});

# timefmt

if( $options{timefmt} )

{

print(PIPE "set timefmt '$options{timefmt}'\n");

print(PIPE "set xdata time\n");

}

# set up histograms

$options{binwidth} ||= 1; # if no binwidth given, set it to 1

print PIPE

"set boxwidth $options{binwidth}\n" .

"histbin(x) = $options{binwidth} * floor(0.5 + x/$options{binwidth})\n";

setCurveAsHistogram( $_ ) foreach (@{$options{histogram}});

if(@{$options{x2y1}} || @{$options{x2y2}})

{

print PIPE "set xtics nomirror\n";

print PIPE "set x2tics\n";

# if any of the ranges are given, set the range

sendRangeCommand( "x2range", $options{x2min}, $options{x2max} );

}

if(@{$options{x1y2}} || @{$options{x2y2}})

{

print PIPE "set ytics nomirror\n";

print PIPE "set y2tics\n";

# if any of the ranges are given, set the range

sendRangeCommand( "y2range", $options{y2min}, $options{y2max} );

}

# if any of the ranges are given, set the range

sendRangeCommand( "xrange", $options{xmin}, $options{xmax} );

sendRangeCommand( "yrange", $options{ymin}, $options{ymax} );

sendRangeCommand( "zrange", $options{zmin}, $options{zmax} );

sendRangeCommand( "cbrange", $options{zmin}, $options{zmax} ) if($options{colormap});

# add the extra global options

print(PIPE "$_\n") foreach (@{$options{extracmds}});

print(PIPE "set $_\n") foreach (@{$options{set}});

print(PIPE "unset $_\n") foreach (@{$options{unset}});

# latest domain variable present in our data

my $latestX;

# The domain of the current point

my @domain;

# column headers from vnlog

my @vnlog_headers;

if($options{vnlog})

{

require Vnlog::Parser;

require Vnlog::Util;

if ( !defined $pipe_in )

{

($pipe_in, $selector) = openNextFile();

}

my $parser = Vnlog::Parser->new();

while (defined ($_ = Vnlog::Util::get_unbuffered_line($pipe_in)))

{

if ( !$parser->parse($_) )

{

die "Error parsing vnlog: $parser->{error}; looking at line '$_'";

}

my $keys = $parser->getKeys();

if (defined $keys)

{

@vnlog_headers = @$keys;

last;

}

}

if(!@vnlog_headers)

{

die "Looked through all of the first file, and never saw a vnlog legend";

}

}

# The x-axis domain represented as a number. This is exactly the same as

# $domain[0] unless the x-axis domain uses a timefmt. Then this is the

# number of seconds since the UNIX epoch.

my $domain0_numeric;

while( defined ($_ = getNextLine()) )

{

next if /^#/o;

if( $options{stream} )

{

if(/^clear/o )

{

clearCurves();

next;

}

if(/^replot/o )

{

replot( $domain0_numeric );

next;

}

last if /^exit/o;

}

# parse the incoming data lines. The format is

# x id0 dat0 id1 dat1 ....

# where idX is the ID of the curve that datX corresponds to

#

# $options{domain} indicates whether the initial 'x' is given or not (if not, the line

# number is used)

# $options{dataid} indicates whether idX is given or not (if not, the point order in the

# line is used)

# 3d plots require $options{domain}, and dictate "x y" for the domain instead of just "x"

my @fields = split;

my $i_column = 0;

if($options{domain})

{

if( $options{timefmt} )

{

# no point if doing anything unless I have at least the domain and

# 1 piece of data

next if @fields < $options{timefmt_Ncols}+1;

$domain[0] = join (' ', splice( @fields, 0, $options{timefmt_Ncols}) );

$domain0_numeric = makeDomainNumeric( $domain[0] );

$i_column += $options{timefmt_Ncols};

}

elsif(!$options{'3d'})

{

# no point if doing anything unless I have at least the domain and

# 1 piece of data

next if @fields < 1+1;

$domain[0] = $domain0_numeric = shift @fields;

$i_column += 1;

}

else

{

# no point if doing anything unless I have at least the domain and

# 1 piece of data

next if @fields < 2+1;

@domain = splice(@fields, 0, 2);

$i_column += 2;

}

if( $options{monotonic} )

{

if( defined $latestX && $domain0_numeric < $latestX )

{

# the x-coordinate of the new point is in the past, so I wipe out

# all the data and start anew. Before I wipe the old data, I

# replot the old data

replot( $domain0_numeric );

clearCurves();

$latestX = undef;

}

else

{ $latestX = $domain0_numeric; }