Initial commit of OpenSPARC T2 design and verification files.

[OpenSPARC-T2-DV] / tools / perl-5.8.0 / lib / site_perl / 5.8.0 / Psh / Joblist.pm

package Psh::Joblist;

use strict;
require Psh::OS;

my @jobs_order=();
my %jobs_list=();

sub create_job {
       my ($pid, $call, $assoc_obj) = @_;

       my $job = new Psh::Job( $pid, $call, $assoc_obj);
       $jobs_list{$pid}=$job;
       push(@jobs_order,$job);
       return $job;
}

sub delete_job {
       my ($pid) = @_;

       my $job= $jobs_list{$pid};
       return if !defined($job);

       delete $jobs_list{$pid};
       my $i;
       for($i=0; $i <= $#jobs_order; $i++) {
               last if( $jobs_order[$i]==$job);
       }

       splice( @jobs_order, $i, 1);
}

sub job_exists {
       my $pid= shift;

       return exists($jobs_list{$pid});
}

sub get_job {
       my $pid= shift;
       return $jobs_list{$pid};
}

sub list_jobs {
       return @jobs_order;
}

sub get_job_number {
       my $pid= shift;

       for( my $i=0; $i<=$#jobs_order; $i++) {
               return $i+1 if( $jobs_order[$i]->{pid}==$pid);
       }
       return -1;
}

#
# $pid=Psh::Joblist::find_job([$jobnumber])
# Finds either the job with the specified job number
# or the highest numbered not running job and returns
# the job or undef is none is found
#
sub find_job {
       my $job_to_start= shift;

       return $jobs_order[$job_to_start] if defined( $job_to_start);

       for (my $i = $#jobs_order; $i >= 0; $i--) {
               my $job = $jobs_order[$i];

               if(!$job->{running}) {
                       return wantarray?($i,$job):$job;
               }
       }
       return undef;
}

sub find_last_with_name {
       my ($name, $runningflag) = @_;
       enumerate();
       my $index=0;
       while( my $job= Psh::Joblist::each()) {
               next if $runningflag && $job->{running};
               my $call= $job->{call};
               if ($call=~ m:([^/\s]+)\s*: ) {
                       $call= $1;
               } elsif( $call=~ m:/([^/\s]+)\s+.*$: ) {
                       $call= $1;
               } elsif ( $call=~ m:^([^/\s]+): ) {
                       $call= $1;
               }
               if( $call eq $name) {
                       return wantarray?($index,$job->{pid},$job->{call}):$index;
               }
               $index++;
       }
       return wantarray?():undef;
}

{
       my $pointer;

#
# Resets the enumeration counter for access using "each"
#
       sub enumerate {
               $pointer=0;
       }

#
# Returns the next job
#
       sub each {
               if ($pointer <= $#jobs_order) {
                       return $jobs_order[$pointer++];
               }
               return undef;
       }
}

package Psh::Job;

#
# $job= new Psh::Job( pid, call);
# Creates a new Job object
# pid is the pid of the object
# call is the name of the executed command
#
sub new {
       my ( $class, $pid, $call, $assoc_obj ) = @_;
       my $self = {};
       bless $self, $class;
       $self->{pid}=$pid;
       $self->{call}=$call;
       $self->{running}=1;
       $self->{assoc_obj}=$assoc_obj;
       return $self;
}

#
# $job->run;
# Sends SIGCONT to the job and records it running
#
sub continue {
       my $self= shift;

       # minus sign to wake up the whole group of the child:
       if( Psh::OS::has_job_control()) {
               Psh::OS::resume_job($self);
       }
       $self->{running}=1;
}

1;
__END__

=head1 NAME

Psh::Joblist - A data structure suitable for handling job lists like bash's

=head1 SYNOPSIS

 use Psh::Joblist;

 $job = Psh::Joblist::create_job($pid,$displayed_command);

 Psh::Joblist::delete_job($pid);

 $job = Psh::Joblist::get_job($pid);

 $flag = Psh::Joblist::job_exists($pid);

 $index = Psh::Joblist::get_job_number($pid);

 $job = Psh::Joblist::find_job();
 $job = Psh::Joblist::find_job($index);

 Psh::Joblist::enumerate();
 while( $job= Psh::Joblist::each()) { ... }

=head1 DESCRIPTION

Read the source ;-)

=head1 AUTHOR

Markus Peter (warp@spin.de)

=cut