Data/Analysis.pm untested

filter: Statementstmt 0.0% 0 / 642 Branchbran 0.0% 0 / 368 Conditioncond 0.0% 0 / 99 MC/DCmcdc 0.0% 0 / 64 Subroutinesub 0.0% 0 / 23 Podpod 0.0% 0 / 17 totaltotal 0.0% 0 / 1213 CC 185 SCAR 63.0
CC
185
Cov
0%
ReadEvent
1640.0
FindEvent
870.0
ReadRunHeader
306.0
CRAP 545.1
1 package Lab::Data::Analysis;
2 #ABSTRACT: Analyze data from 'Trace' files
3 $Lab::Data::Analysis::VERSION = '3.901';
4 use v5.20;
5  
6 use strict;
7 use Clone qw(clone);
8 use warnings;
9 use Carp;
10 use Data::Dumper;
11  
12 # default config values, copied to $self->{CONFIG} initially
13  
14 our $DEFAULT_CONFIG = {
15 use_ftell => 0, # use ftell/fsetpos for positioning
16 clone_headers => 1, # clone run/file headers into events
17 combined_gpib => 0, # also combine GPIB from all streams
18 };
19  
20 our $_DefaultAnalyzer = {
21 1 => { # order in which to check for match
22 MATCH =>
23 '(?i)^Lab::Instrument::(TDS|TPS|TBS)(1\d\d\d|2\d\d\d?)(B|C)?::',
24 TYPE => 'Lab::Data::Analysis::TekTDS',
25 COMMENT =>
26 'Tektronix TDS/TPS/TBS 1000 and 2000 series, TDS200 series, oscilloscopes'
27 },
28 2 => {
29 MATCH => '(?i)^Lab::Instrument::DPO4\d\d\d(A-C)?::',
30 TYPE => 'Lab::Data::Analysis::TekDPO',
31 COMMENT => 'Tektronix DPO4000 series oscilloscopes',
32 },
33  
34 3 => {
35 MATCH => '(?i)^Lab::Instrument::WR\d+::',
36 TYPE => 'Lab::Data::Analysis::WaveRunner',
37 COMMENT => 'LeCroy WaveRunner series oscilloscopes',
38 },
39 };
40  
41 our $_LOADED = {};
42  
43  
44 sub new {
45 my $proto = shift;
46 my $class = ref($proto) || $proto;
47 my $self = {};
48 bless $self, $class;
49  
50 my ( $file, $tail ) = $self->_check_args( \@_, qw(file) );
51 $self->{FILE} = undef;
52 $self->{FH} = undef;
53 $self->{INDEX} = undef;
54 $self->{CONFIG} = {};
55 $self->{FILEHEADER} = undef;
56 $self->{RUNHEADER} = undef;
57  
58 # set up the default config variables
59 foreach my $k ( keys( %{$DEFAULT_CONFIG} ) ) {
60 $self->{CONFIG}->{$k} = $DEFAULT_CONFIG->{$k};
61 }
62  
63 # override default config with user-provided parameters
64 foreach my $k ( keys( %{$tail} ) ) {
65 next unless exists $self->{CONFIG}->{$k};
66 $self->{CONFIG}->{$k} = $tail->{$k};
67 }
68  
69 $self->open($file) if defined($file);
70  
71 return $self;
72 }
73  
74 ################ internal routines ########################
75  
76 # calling argument parsing; this is an extension of the
77 # _check_args and _check_args_strict routines in Instrument.pm,
78 # allowing more flexibility in how routines are called.
79 # In particular routine(a=>1,b=>2,..) and
80 # routine({a=>1,b=>2,..}) can both be used.
81  
82 # note: if this code does not properly recognize the syntax,
83 # then you have to use the {key=>value...} form.
84  
85 # calling:
86 # ($par1,$par2,$par3,$tail) = $self->_check_args(\@_,qw(par1 par2 par3));
87 # or, for compatibility:
88 # ($par1,$par2,$par3,$tail) = $self->_check_args(\@_,[qw(par1 par2 par3)]);
89  
90 # can also call without the $self-> pointer, since not used.
91  
92 sub _check_args {
93 my $self = shift;
94 my $args;
95  
96 if ( ref($self) eq 'ARRAY' ) {
97 $args = $self;
98 }
99 else {
100 $args = shift;
101 }
102 my $params = [@_];
103 $params = $params->[0] if ref( $params->[0] ) eq 'ARRAY';
104 my $arguments = {};
105  
106 if ( $#{$args} == 0 && ref( $args->[0] ) eq 'HASH' ) { # case 3
107 %{$arguments} = ( %{ $args->[0] } );
108 }
109 else {
110 my $simple = 1;
111 if ( $#{$args} & 1 == 1 ) { # must have even # arguments
112 my $found = {};
113 for ( my $j = 0; $j <= $#{$args}; $j += 2 ) {
114 if ( ref( $args->[$j] ) ne '' ) { # a ref for a key? no
115 $simple = 1;
116 last;
117 }
118 foreach my $p ( @{$params} ) { # named param
119 $simple = 0 if $p eq $args->[$j];
120 }
121 if ( exists( $found->{ $args->[$j] } ) ) { # key used 2x? no
122 $simple = 1;
123 last;
124 }
125 $found->{ $args->[$j] } = 1;
126 }
127 }
128  
129 if ($simple) { # case 1
130 my $i = 0;
131 my $j = 0;
132 foreach my $arg ( @{$args} ) {
133 if ( defined @{$params}[$i] ) {
134 $arguments->{ @{$params}[$i] } = $arg;
135 $i++;
136 }
137 else {
138 $arguments->{"_tail$j"} = $arg;
139 $j++;
140 }
141 }
142 }
143 else { # case 2
144 %{$arguments} = ( @{$args} );
145 }
146 }
147  
148 my @return_args = ();
149  
150 foreach my $param ( @{$params} ) {
151 if ( exists $arguments->{$param} ) {
152 push( @return_args, $arguments->{$param} );
153 delete $arguments->{$param};
154 }
155 else {
156 push( @return_args, undef );
157 }
158 }
159  
160 push( @return_args, $arguments );
161  
162 if (wantarray) {
163 return @return_args;
164 }
165 else {
166 return $return_args[0];
167 }
168 }
169  
170 sub _check_args_strict {
171 my $self = shift;
172 my $args;
173  
174 if ( ref($self) eq 'ARRAY' ) {
175 $args = $self;
176 }
177 else {
178 $args = shift;
179 }
180 my $params = [@_];
181 $params = $params->[0] if ref( $params->[0] ) eq 'ARRAY';
182  
183 my @result = _check_args( $args, $params );
184  
185 my $num_params = @result - 1;
186  
187 for ( my $i = 0; $i < $num_params; ++$i ) {
188 if ( not defined $result[$i] ) {
189 croak("missing mandatory argument '$params->[$i]'");
190 }
191 }
192  
193 if (wantarray) {
194 return @result;
195 }
196 else {
197 return $result[0];
198 }
199 }
200  
201 # get file position, make use of CONFIG option
202  
203 sub _tell {
204 my $self = shift;
205 croak("no file open") unless defined $self->{FH};
206 if ( $self->{CONFIG}->{use_ftell} ) {
207 return $self->{FH}->getpos();
208 }
209 else {
210 return $self->{FH}->tell();
211 }
212 }
213  
214 # set file absolute position, making use of CONFIG option
215 # ignores any 'whence' parameter
216  
217 sub _seek {
218 my $self = shift;
219 my $p = shift;
220 croak("no file open") unless defined $self->{FH};
221 if ( $self->{CONFIG}->{use_ftell} ) {
222 return $self->{FH}->setpos($p);
223 }
224 else {
225 return $self->{FH}->seek( $p, 0 );
226 }
227 }
228  
229  
230 sub open {
231 my $self = shift;
232 my ( $file, $tail ) = _check_args_strict( \@_, 'file' );
233  
234 croak("input file '$file' does not exist") unless -e $file;
235 croak("input file '$file' not readable") unless -r $file;
236  
237 $self->{FH}->close() if defined $self->{FH};
238  
239 $self->{FH} = IO::File->new( $file, "r" );
240 croak("unable to open file '$file' for reading")
241 unless defined $self->{FH};
242 $self->{FILE} = $file;
243 $self->{FILE_BEGIN} = $self->_tell(); # beginning position
244 $self->{INDEX} = undef;
245 $self->{FSTAT} = [ ( $self->{FH}->stat() ) ];
246  
247 }
248  
249  
250 sub rewind {
251 my $self = shift;
252 my ($tail) = _check_args( \@_ );
253  
254 croak("tracefile not opened") unless defined $self->{FH};
255  
256 $self->_seek( $self->{FILE_BEGIN} );
257 }
258  
259  
260 sub MakeIndex {
261 my $self = shift;
262 my ($tail) = _check_args( \@_ );
263  
264 my $fh = $self->{FH};
265 croak("no tracefile opened") unless defined $fh;
266  
267 my $iloc = $self->_tell();
268 my $p = $self->{FILE_BEGIN};
269  
270 $self->_seek($p); # beginning
271 $self->{INDEX} = {};
272 $self->{INDEX}->{RUN} = {};
273 $self->{INDEX}->{STREAM} = {};
274 $self->{RUN} = undef;
275 $self->{EVENT} = undef;
276 my $run = 0;
277 my $n = 1;
278  
279 while (<$fh>) {
280 my $pnext = $self->_tell();
281 if ( !/^(\d+)(.)(.*)\s*$/ ) {
282 carp("Error parsing trace file at line $n: $_");
283 $p = $pnext;
284 next;
285 }
286 my $str = $1 + 0;
287 my $cc = $2;
288 my $rest = eval($3);
289  
290 if ( !exists( $self->{INDEX}->{STREAM}->{$str} ) ) {
291 $self->{INDEX}->{STREAM}->{$str} = {};
292 $self->{INDEX}->{STREAM}->{$str}->{COMMENT} = {};
293 $self->{INDEX}->{STREAM}->{$str}->{NUMBER} = $str;
294 }
295  
296 if ( $cc ne '<' && $cc ne '>' ) {
297  
298 if ( $cc eq '*' ) {
299 if ( $rest =~ /^Lab::[\w\:]+::new\s/i ) {
300 $self->{INDEX}->{STREAM}->{$str}->{CONNECT} = $rest;
301 }
302 elsif ( $rest =~ /^start\s+run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i )
303 {
304 $run = $1 + 0;
305 my $t0 = $2;
306 carp("duplicate run '$run' at line $n")
307 if exists $self->{INDEX}->{RUN}->{$run};
308 if ( !defined( $self->{RUN} ) ) {
309 $self->{RUN} = $run;
310 $self->{EVENT} = 0;
311 }
312 $self->{INDEX}->{RUN}->{$run} = {};
313 $self->{INDEX}->{RUN}->{$run}->{POSITION} = $p;
314 $self->{INDEX}->{RUN}->{$run}->{STARTTIME} = $t0;
315 $self->{INDEX}->{RUN}->{$run}->{EVENT} = {};
316 }
317 elsif ( $rest
318 =~ /^event\s*(\d+)\s*run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i ) {
319 carp("event found outside of its run at line $n")
320 unless $run == $2 + 0;
321 my $event = $1 + 0;
322 my $te = $3;
323 carp("duplicate event '$event', run '$run' at line $n")
324 if exists $self->{INDEX}->{RUN}->{$run}->{EVENT}
325 ->{$event};
326 $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event} = {};
327 $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event}
328 ->{POSITION} = $p;
329 $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event}->{TIME}
330 = $te;
331 }
332 elsif ( $rest =~ /^stop\s+run(\d+)\s.*\\?\@\s*([\d\.]+)/i ) {
333 carp("run # mismatch at start/stop at line $n")
334 unless $run == $1 + 0;
335 $run = $1 + 0;
336 my $t1 = $2;
337 $self->{INDEX}->{RUN}->{$run}->{STOPTIME} = $t1;
338 $run = 0;
339 }
340 else {
341 carp(
342 "ignoring unknown control sequence at line $n: $rest"
343 );
344 }
345 }
346 elsif ( $cc eq '|' ) {
347 $self->{INDEX}->{STREAM}->{$str}->{COMMENT}->{$p} = $rest;
348 }
349 else {
350 carp("unknown trace control char at line $n\n");
351 }
352 }
353 $p = $pnext;
354 $n++;
355 }
356 $self->_seek($iloc);
357 }
358  
359  
360 sub PrintIndex {
361 my $self = shift;
362 my ( $print_events, $tail ) = _check_args( \@_, qw(print_events) );
363  
364 if ( !defined( $self->{INDEX} ) ) {
365 carp "No index generated yet";
366 return;
367 }
368  
369 my $dirty = 0;
370 foreach my $str ( sort( keys( %{ $self->{INDEX}->{STREAM} } ) ) ) {
371 next if $str == 0;
372 if ( !$dirty ) {
373 print "======= DATA STREAMS ==========\n";
374 $dirty = 1;
375 }
376 my $text = $self->{INDEX}->{STREAM}->{$str}->{CONNECT};
377 $text =~ s/\\"/"/g;
378  
379 my $len = length($text);
380 my $j = 0;
381 while ( $j == 0 || $j < $len ) {
382 print "$str :" if $j == 0;
383 print "\t", substr( $text, $j, 64 ) if $j < $len;
384 print "\n";
385 $j += 64;
386 }
387  
388 # print "$str\t",$self->{INDEX}->{STREAM}->{$str}->{CONNECT},"\n";
389 my $d2 = 0;
390 foreach my $c (
391 sort( keys( %{ $self->{INDEX}->{STREAM}->{$str}->{COMMENT} } ) ) )
392 {
393 $d2 = 1;
394 print "\t", $self->{INDEX}->{STREAM}->{$str}->{COMMENT}->{$c},
395 "\n";
396 }
397 print "\n" if $d2;
398 }
399 print "\n" if $dirty;
400 $dirty = 0;
401  
402 foreach my $run ( sort( keys( %{ $self->{INDEX}->{RUN} } ) ) ) {
403 if ( !$dirty ) {
404 print "======= RUNS ==========\n";
405 $dirty = 1;
406 }
407 my (@e) = ( keys( %{ $self->{INDEX}->{RUN}->{$run}->{EVENT} } ) );
408 my $t0 = localtime( $self->{INDEX}->{RUN}->{$run}->{STARTTIME} );
409 my $t1;
410 $t1 = localtime( $self->{INDEX}->{RUN}->{$run}->{STOPTIME} )
411 if exists( $self->{INDEX}->{RUN}->{$run}->{STOPTIME} );
412 if ( !defined($t1) ) { # use file modification time
413 $t1 = localtime( $self->{FSTAT}->[9] ) . '?';
414 }
415 printf(
416 "RUN %08d :\t% 8d events\t(%s)..(%s)\n", $run, $#e + 1, $t0,
417 $t1
418 );
419  
420 if ( defined($print_events) && $print_events ) {
421 print "\t EVENT\t FILE POSITION \t TIME\n";
422 foreach my $ev ( sort(@e) ) {
423 $t0 = localtime(
424 $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$ev}->{TIME} );
425 my $pos = $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$ev}
426 ->{POSITION};
427 printf( "\t% 8d\t% 16d\t%s\n", $ev, $pos, $t0 );
428 }
429 print "\n";
430 }
431  
432 }
433 print "\n" if $dirty;
434  
435 }
436  
437  
438 sub ReadEvent {
439 my $self = shift;
440 my ( $stream, $inrun, $inevent, $tail )
441 = _check_args( \@_, qw(stream run event) );
442  
443 # turn stream selection into an array ref, however passed.
444 my $streams = {};
445 if ( defined($stream) ) {
446 if ( ref($stream) eq '' ) {
447 $stream = [$stream];
448 }
449  
450 foreach my $s ( @{$stream} ) {
451 $streams->{$s} = 1;
452 }
453 $streams->{0} = 1
454 unless exists( $tail->{no_global} ) && !$tail->{no_global};
455 }
456  
457 my $fh = $self->{FH};
458 croak("data file is not open") unless defined $fh;
459  
460 if ( defined($inrun) || defined($inevent) ) {
461 return undef
462 unless
463 defined( $self->FindEvent( run => $inrun, event => $inevent ) );
464 }
465  
466 my $p = $self->_tell();
467 my $ev = {
468 GPIB => [],
469 COMMENT => [],
470 STREAM => {},
471 FILEHEADER => undef,
472 RUNHEADER => undef,
473 CONFIG => clone( $self->{CONFIG} ),
474 };
475  
476 if ( !defined( $self->{INDEX} ) ) {
477  
478 my $inevent = 0;
479  
480 while (<$fh>) {
481 chomp;
482 my $pnext = $self->_tell();
483 if ( !/^(\d+)(.)(.*)\s*$/ ) {
484 carp("Error parsing trace file: $_");
485 $p = $pnext;
486 next;
487 }
488 my $str = $1 + 0;
489 my $cc = $2;
490 my $rest = eval($3);
491  
492 if ( $cc eq '*' ) {
493 if ( $rest =~ /^Lab::[\w\:]+::new\s/i ) {
494 ;
495 }
496 elsif ( $rest =~ /^start\s+run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i )
497 {
498 last if $inevent;
499 }
500 elsif ( $rest
501 =~ /^event\s*(\d+)\s*run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i ) {
502 last if $inevent;
503  
504 $inevent = 1;
505 $ev->{EVENT} = $1 + 0;
506 $ev->{RUN} = $2 + 0;
507 $ev->{TIME} = $3;
508 $ev->{POSITION} = $p;
509 if ( $self->{CONFIG}->{clone_headers} ) {
510 $ev->{FILEHEADER} = clone( $self->{FILEHEADER} )
511 if defined $self->{FILEHEADER};
512 $ev->{RUNHEADER} = clone( $self->{RUNHEADER} )
513 if defined $self->{RUNHEADER};
514 }
515 }
516 elsif ( $rest =~ /^stop\s+run(\d+)\s.*\\?\@\s*([\d\.]+)/i ) {
517 last if $inevent;
518 }
519 else {
520 carp("ignoring unknown control sequence: $rest");
521 }
522 }
523 elsif ( $cc eq '|' ) {
524 if ( $inevent
525 && ( !defined($stream) || exists( $streams->{$str} ) ) ) {
526  
527 push( @{ $ev->{COMMENT} }, $rest );
528 $ev->{STREAM}->{$str} = {
529 COMMENT => [],
530 GPIB => [],
531 NUMBER => $str,
532 CONFIG => clone( $self->{CONFIG} ),
533 } unless exists $ev->{STREAM}->{$str};
534 push( @{ $ev->{STREAM}->{$str}->{COMMENT} }, $rest );
535 }
536 }
537 elsif ( $cc eq '<' || $cc eq '>' ) {
538 if ( $inevent
539 && ( !defined($stream) || exists( $streams->{$str} ) ) ) {
540 push( @{ $ev->{GPIB} }, $cc . $rest )
541 if $self->{CONFIG}->{combine_gpib};
542 $ev->{STREAM}->{$str} = {
543 COMMENT => [],
544 GPIB => [],
545 NUMBER => $str,
546 CONFIG => clone( $self->{CONFIG} ),
547 } unless exists $ev->{STREAM}->{$str};
548 push( @{ $ev->{STREAM}->{$str}->{GPIB} }, $cc . $rest );
549 }
550 }
551 else {
552 carp("unknown trace control char '$cc'\n");
553 }
554 $p = $pnext;
555 }
556  
557 return undef unless $inevent;
558 $self->_seek($p);
559 $self->{RUN} = $ev->{RUN};
560 $self->{EVENT} = $ev->{EVENT};
561  
562 }
563 else {
564 my $run = $self->{RUN};
565 my $event = $self->{EVENT} + 1;
566 return undef unless exists $self->{INDEX}->{RUN}->{$run};
567 return undef
568 unless exists $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event};
569 my $pev
570 = $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event}->{POSITION};
571 $ev->{RUN} = $run;
572 $ev->{EVENT} = $self->{EVENT} = $event;
573 $ev->{POSITION} = $pev;
574 $ev->{TIME}
575 = $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event}->{TIME};
576 $ev->{STREAM} = {};
577 $ev->{GPIB} = [];
578 $ev->{COMMENT} = [];
579 $ev->{CONFIG} = clone( $self->{CONFIG} );
580  
581 if ( $self->{CONFIG}->{clone_headers} ) {
582 $ev->{FILEHEADER} = clone( $self->{FILEHEADER} )
583 if defined $self->{FILEHEADER};
584 $ev->{RUNHEADER} = clone( $self->{RUNHEADER} )
585 if defined $self->{RUNHEADER};
586 }
587  
588 $self->_seek($pev);
589 my $foo = <$fh>;
590 my $p;
591 while (<$fh>) {
592 $p = $self->_tell();
593 if ( !/^(\d+)(.)(.*)\s*$/ ) {
594 carp("Error parsing trace file at line : $_");
595 next;
596 }
597 my $str = $1 + 0;
598 my $cc = $2;
599 my $rest = eval($3);
600  
601 last if $cc eq '*';
602 next unless !defined($stream) || exists( $streams->{$str} );
603 $ev->{STREAM}->{$str} = {
604 COMMENT => [],
605 GPIB => [],
606 NUMBER => $str,
607 CONFIG => clone( $self->{CONFIG} ),
608 } unless exists $ev->{STREAM}->{$str};
609  
610 if ( $cc eq '|' ) {
611 push( @{ $ev->{COMMENT} }, $rest );
612 push( @{ $ev->{STREAM}->{$str}->{COMMENT} }, $rest );
613 }
614 elsif ( $cc eq '>' || $cc eq '<' ) {
615 push( @{ $ev->{GPIB} }, $cc . $rest )
616 if $self->{CONFIG}->{combine_gpib};
617 push( @{ $ev->{STREAM}->{$str}->{GPIB} }, $cc . $rest );
618 }
619 else {
620 carp("unknown trace control char '$cc'\n");
621 }
622 }
623 }
624 $self->_seek($p); # position at start of next event/control line
625 return $ev;
626 }
627  
628  
629 sub ReadFileHeader {
630 my $self = shift;
631 my ( $in, $tail ) = _check_args( \@_, 'shift' );
632  
633 my $fh = $self->{FH};
634 croak("No trace file open") unless defined $fh;
635  
636 my $shift = 0;
637 if ( defined($in) && $in =~ /^\s*(Y|T|[1-9])/i ) {
638 $shift = 1;
639 }
640 $self->{FILEHEADER} = undef;
641  
642 my $ipos = $self->_tell();
643  
644 my $p = $self->{FILE_BEGIN};
645 $self->_seek($p);
646 my $hdr = {};
647  
648 $hdr->{POSITION} = $p;
649 $hdr->{STREAM} = {};
650  
651 while (<$fh>) {
652 my $pnext = $self->_tell();
653 if ( !/^(\d+)(.)(.*)\s*$/ ) {
654 carp("Error parsing trace file : $_");
655 $p = $pnext;
656 next;
657 }
658 my $str = $1 + 0;
659 my $cc = $2;
660 my $rest = eval($3);
661  
662 $hdr->{STREAM}->{$str} = {
663 COMMENT => [],
664 GPIB => [],
665 NUMBER => $str,
666 CONNECT => undef,
667 } unless exists $hdr->{STREAM}->{$str};
668  
669 if ( $cc eq '*' ) {
670 last if $rest =~ /^start\s+run/i;
671 last if $rest =~ /^event/i;
672 last if $rest =~ /^stop/i;
673 if ( $rest =~ /^Lab::/i ) {
674 $hdr->{STREAM}->{$str}->{CONNECT} = $rest;
675 }
676 else {
677 carp("ignoring unknown control sequence: $rest");
678 }
679 }
680 elsif ( $cc eq '|' ) {
681 push( @{ $hdr->{STREAM}->{$str}->{COMMENT} }, $rest );
682 }
683 elsif ( $cc eq '<' || $cc eq '>' ) {
684 push( @{ $hdr->{STREAM}->{$str}->{GPIB} }, $cc . $rest );
685 }
686 else {
687 carp("unknown trace control char '$cc' at line\n");
688 }
689 $p = $pnext;
690 }
691 if ($shift) {
692 $self->_seek($p);
693 }
694 else {
695 $self->_seek($ipos);
696 }
697 $self->{FILEHEADER} = $hdr;
698 return $hdr;
699 }
700  
701  
702 sub ReadRunHeader {
703 my $self = shift;
704 my ( $selrun, $tail ) = _check_args( \@_, qw(run) );
705  
706 my $fh = $self->{FH};
707 croak("no tracefile opened") unless defined $fh;
708  
709 my $hdr = {
710 STREAM => {},
711 };
712 my $ipos = $self->_tell();
713  
714 if ( defined( $self->{INDEX} ) && defined($selrun) ) {
715 if ( exists( $self->{INDEX}->{RUN}->{$selrun} ) ) {
716 $self->_seek( $self->{INDEX}->{RUN}->{$selrun}->{POSITION} );
717 $self->{RUN} = $selrun;
718 }
719 else {
720 return undef;
721 }
722 }
723 else {
724  
725 my $p = $ipos;
726 my $foundrun = 0;
727  
728 while (<$fh>) {
729 my $pnext = $self->_tell();
730  
731 if ( !/^(\d+)(.)(.*)\s*$/ ) {
732 carp("Error parsing trace file : $_");
733 next;
734 }
735 my $str = $1 + 0;
736 my $cc = $2;
737 my $rest = eval($3);
738  
739 if ( $cc eq '*' ) {
740 if ( $rest =~ /^start\s+run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i ) {
741 my $run = $1 + 0;
742 if ( !defined($selrun) || $selrun == $run ) {
743 $foundrun = 1;
744 $self->{RUN} = $run;
745 last;
746 }
747 }
748 }
749 $p = $pnext;
750 }
751 if ( !$foundrun ) {
752 $self->_seek($ipos);
753 return undef;
754 }
755 $self->_seek($p);
756 }
757  
758 my $p = $self->_tell();
759 while (<$fh>) {
760 my $pnext = $self->_tell();
761  
762 if ( !/^(\d+)(.)(.*)\s*$/ ) {
763 carp("Error parsing trace file: $_");
764 next;
765 }
766 my $str = $1 + 0;
767 my $cc = $2;
768 my $rest = eval($3);
769  
770 $hdr->{STREAM}->{$str} = {
771 COMMENT => [],
772 GPIB => [],
773 NUMBER => $str,
774 } unless exists $hdr->{STREAM}->{$str};
775  
776 if ( $cc eq '*' ) {
777 if ( $rest =~ /^start\s+run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i ) {
778 my $run = $1 + 0;
779 last if $self->{RUN} != $run;
780  
781 $hdr->{RUN} = $run;
782 $hdr->{POSITION} = $p;
783 $hdr->{STARTTIME} = $2;
784  
785 }
786 elsif ( $rest =~ /^(event|stop|Lab::)/i ) {
787 last;
788 }
789 else {
790 carp("ignoring unknown control sequence : $rest");
791 }
792 }
793 elsif ( $cc eq '|' ) {
794 push( @{ $hdr->{STREAM}->{$str}->{COMMENT} }, $rest );
795 }
796 elsif ( $cc eq '>' || $cc eq '<' ) {
797 push( @{ $hdr->{STREAM}->{$str}->{GPIB} }, $cc . $rest );
798 }
799 else {
800 carp("unknown trace control char '$cc'\n");
801 }
802 $p = $pnext;
803 }
804 $self->_seek($p);
805  
806 $self->{RUNHEADER} = $hdr;
807 return $hdr;
808 }
809  
810  
811 sub FindEvent {
812 my $self = shift;
813 my ( $run, $event, $tail ) = _check_args( \@_, 'run', 'event' );
814  
815 if ( !defined($run) || $run <= 0 ) {
816 $run = $self->{RUN};
817 }
818 if ( !defined($run) || $run <= 0 ) {
819 carp("invalid run (undef? <=0?)");
820 return undef;
821 }
822  
823 if ( exists( $self->{INDEX} ) ) {
824 return undef unless exists $self->{INDEX}->{RUN}->{$run};
825 my (@ev)
826 = ( sort( keys( %{ $self->{INDEX}->{RUN}->{$run}->{EVENT} } ) ) );
827 if ( !defined($event) ) {
828 if ( defined( $self->{EVENT} ) ) {
829 $event = $self->{EVENT} + 1;
830 }
831 else {
832 $event = 0;
833 }
834 }
835 if ( $event == 0 ) {
836 $event = $ev[0];
837 }
838 elsif ( $event < 0 ) {
839 $event = $ev[$event];
840 }
841 return undef
842 unless exists $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event};
843 my $p = $self->{INDEX}->{RUN}->{$run}->{EVENT}->{$event}->{POSITION};
844 $self->_seek($p);
845 return $p;
846 }
847 else {
848 my $fh = $self->{FH};
849 croak("no file opened") unless defined $fh;
850  
851 my $p = $self->_tell();
852 my $pstart = $p;
853 my $foundrun = 0;
854 my $foundevent = 0;
855 my $wrapped = 0;
856  
857 if ( !defined($event) ) {
858 if ( defined( $self->{EVENT} ) ) {
859 $event = $self->{EVENT} + 1;
860 }
861 else {
862 $event = 0;
863 }
864 }
865 $event = 0 if $event < 0;
866  
867 while ( !$wrapped ) {
868 while (<$fh>) {
869 my $pnext = $self->_tell();
870 last if $pnext == $pstart; # wrapped the file
871  
872 if ( !/^(\d+)(.)(.*)\s*$/ ) {
873 carp("Error parsing trace file: $_");
874 next;
875 }
876 my $str = $1 + 0;
877 my $cc = $2;
878 my $rest = eval($3);
879  
880 if ( $cc eq '*' ) {
881 if (
882 $rest =~ /^start\s+run\s*(\d+)\s*\\?\@\s*([\d\.]+)/i )
883 {
884 my $gotrun = $1 + 0;
885 if ( $foundrun && ( $gotrun != $run ) )
886 { # ran off the end of desired run, wrap
887 $foundrun = 0;
888 last;
889 }
890 $foundrun = ( $gotrun == $run );
891 }
892 elsif ( $rest =~ /^event\s*(\d+)\s*run\s*(\d+)/i ) {
893 my $gotev = $1 + 0;
894 my $gotrun = $2 + 0;
895 if ( $foundrun && ( $gotrun != $run ) )
896 { # ran off the end of desired run, wrap
897 $foundrun = 0;
898 last;
899 }
900 $foundrun = ( $gotrun == $run );
901 if ($foundrun) {
902 $foundevent = 1
903 if $event == 0 || $event == $gotev;
904 last if $foundevent;
905 }
906 }
907 elsif ( $rest =~ /^stop\s+run\s*(\d+)/i ) {
908 my $gotrun = $1 + 0;
909 if ($foundrun)
910 { # ran off the end of desired run, wrap
911 $foundrun = 0;
912 last; # wrap the file
913 }
914 }
915 }
916 $p = $pnext;
917 }
918 last if $wrapped;
919 last if $foundrun && $foundevent;
920 $wrapped = 1;
921 $p = $self->{FILE_BEGIN};
922 $self->_seek($p);
923 }
924 if ( !$foundrun || !$foundevent ) {
925 $self->_seek($pstart);
926 return undef;
927 }
928 $self->{RUN} = $run;
929 $self->{EVENT} = $event;
930 $self->_seek($p);
931 return $p;
932 }
933 }
934  
935  
936 sub PrintDefaultAnalyzer {
937 my $self = shift;
938 my ( $in, $tail ) = _check_args( \@_, 'stream' );
939  
940 my $stream;
941 if ( defined($in) ) {
942 $stream = {};
943 if ( ref($in) eq 'ARRAY' ) {
944 $stream->{$in} = 1;
945 }
946 elsif ( ref($in) eq '' ) {
947 $stream->{$in} = 1;
948 foreach my $k ( keys( %{$tail} ) ) {
949 next unless $k =~ /^_tail\d+$/;
950 $stream->{ $tail->{$k} } = 1;
951 }
952 }
953 else {
954 croak("parameter type mismatch");
955 }
956 }
957  
958 $self->ReadFileHeader() unless defined $self->{FILEHEADER};
959  
960 my $dirty = 0;
961 foreach my $s ( sort( keys( %{ $self->{FILEHEADER}->{STREAM} } ) ) ) {
962 next if $s == 0;
963 next if defined($stream) && !exists( $stream->{$s} );
964 my $aType = $self->_findDefAnalyzer($s);
965 next unless defined $aType;
966  
967 print "Stream\tAnalyzer\n" unless $dirty;
968 $dirty = 1;
969 print " $s \t$aType\n";
970 }
971 print "\n" if $dirty;
972 }
973  
974  
975 sub ConnectAnalyzer {
976 my $self = shift;
977 my ( $instr, $inmod, $tail ) = _check_args( \@_, qw(stream module) );
978  
979 $self->ReadFileHeader() unless defined $self->{FILEHEADER};
980 foreach my $str ( keys( %{ $self->{FILEHEADER}->{STREAM} } ) ) {
981 next if $str == 0;
982 if ( !defined($instr) || $instr == $str ) {
983 my $defmod = $self->_findDefAnalyzer($str);
984 if ( defined($inmod) ) {
985 if ( $inmod !~ /::/
986 && !-e "$inmod.pm"
987 && defined($defmod)
988 && $defmod =~ /::${inmod}$/ ) { # default short name
989 $inmod = $defmod;
990 }
991 }
992 else {
993 $inmod = $self->_findDefAnalyzer($str);
994 }
995 if ( !defined($inmod) ) {
996 carp("No analysis module defined for stream $str");
997 return;
998 }
999 if ( !exists( $_LOADED->{$inmod} ) ) {
1000 eval("use $inmod;");
1001 croak($@) if $@;
1002 $_LOADED->{$inmod} = 1;
1003 }
1004 my $strhdr = $self->{FILEHEADER}->{STREAM}->{$str};
1005  
1006 $self->{FILEHEADER}->{STREAM}->{$str}->{ANALYSIS} = []
1007 unless
1008 exists $self->{FILEHEADER}->{STREAM}->{$str}->{ANALYSIS};
1009  
1010 my $a;
1011 eval( '$a = ' . $inmod . '->new(stream=>$strhdr);' );
1012 croak("error connecting analyzer $inmod") unless defined $a;
1013 push(
1014 @{ $self->{FILEHEADER}->{STREAM}->{$str}->{ANALYSIS} },
1015 $a
1016 );
1017 }
1018 }
1019 }
1020  
1021 sub _findDefAnalyzer {
1022 my $self = shift;
1023 my $str = shift;
1024 return undef if $str == 0;
1025 $self->ReadFileHeader() unless defined $self->{FILEHEADER};
1026 return undef unless exists $self->{FILEHEADER}->{STREAM}->{$str};
1027  
1028 my $con = $self->{FILEHEADER}->{STREAM}->{$str}->{CONNECT};
1029  
1030 foreach my $aNum ( sort( keys( %{$_DefaultAnalyzer} ) ) ) {
1031 my $aMatch = $_DefaultAnalyzer->{$aNum}->{MATCH};
1032 next unless $con =~ /$aMatch/;
1033 my $aType = $_DefaultAnalyzer->{$aNum}->{TYPE};
1034 return $aType;
1035 }
1036 return undef;
1037 }
1038  
1039  
1040 sub Analyze {
1041 my $self = shift;
1042 my ( $event, $opts, $str, $tail )
1043 = _check_args( \@_, 'event', 'options', 'stream' );
1044  
1045 if ( !defined($event) || ref($event) ne 'HASH' ) {
1046 carp("bad/missing event");
1047 return undef;
1048 }
1049 return undef unless exists $self->{FILEHEADER};
1050 return undef unless exists $self->{FILEHEADER}->{STREAM};
1051 $opts = {} unless defined $opts;
1052  
1053 my $stream;
1054  
1055 if ( defined($str) ) {
1056 if ( ref($str) eq 'ARRAY' ) {
1057 $stream = {};
1058 foreach my $s ( @{$str} ) {
1059 $stream->{$s} = 1;
1060 }
1061 }
1062 elsif ( ref($str) eq '' ) {
1063 $stream = { $str => 1 };
1064 foreach my $k ( sort( keys( %{$tail} ) ) ) {
1065 next unless $k =~ /^_tail\d+/i;
1066 next unless $tail->{$k} =~ /^\d+$/;
1067 $stream->{ $tail->{$k} } = 1;
1068 delete( $tail->{$k} );
1069 }
1070 }
1071 else {
1072 carp("bad stream parameter");
1073 }
1074 }
1075  
1076 #
1077 # scan through the streams, skipping ones we don't analyze
1078 #
1079  
1080 foreach my $s ( sort( keys( %{ $self->{FILEHEADER}->{STREAM} } ) ) ) {
1081 if ( !defined($stream) || exists( $stream->{$s} ) ) {
1082 next
1083 unless exists $self->{FILEHEADER}->{STREAM}->{$s}->{ANALYSIS};
1084  
1085 # if multiple analyses are connected, do them in sequence
1086  
1087 foreach
1088 my $a ( @{ $self->{FILEHEADER}->{STREAM}->{$s}->{ANALYSIS} } )
1089 {
1090 $event = $a->Analyze( $event, $opts );
1091 if ( !defined($event) ) {
1092 carp( "Stream $s analysis " . ref($a) . " failed" );
1093 return undef;
1094 }
1095 }
1096 }
1097 }
1098  
1099 return $event;
1100 }
1101  
1102 1; # End of Lab::Data::Analysis
1103  
1104 __END__