[BACK]Return to lonstathelpers.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / interface / statistics

Diff for /loncom/interface/statistics/lonstathelpers.pm between versions 1.2 and 1.10

version 1.2, 2004/01/20 15:51:06 version 1.10, 2004/03/31 05:24:00
Line 59  use Apache::lonlocal; Line 59  use Apache::lonlocal;
 use HTML::Entities();  use HTML::Entities();
 use Time::Local();  use Time::Local();
 use Spreadsheet::WriteExcel();  use Spreadsheet::WriteExcel();
   use GDBM_File;
   use Storable qw(freeze thaw);
   
 ####################################################  ####################################################
 ####################################################  ####################################################
Line 123  sub ProblemSelector { Line 125  sub ProblemSelector {
             next if ($res->{'type'} ne 'assessment');              next if ($res->{'type'} ne 'assessment');
             foreach my $part (@{$res->{'parts'}}) {              foreach my $part (@{$res->{'parts'}}) {
                 my $partdata = $res->{'partdata'}->{$part};                  my $partdata = $res->{'partdata'}->{$part};
                 if ((! exists($partdata->{'option'}) ||   
                      $partdata->{'option'} == 0      ) &&  
                     (! exists($partdata->{'radiobutton'}) ||  
                      $partdata->{'radiobutton'} == 0)) {  
                     next;  
                 }  
                 for (my $i=0;$i<scalar(@{$partdata->{'ResponseTypes'}});$i++){                  for (my $i=0;$i<scalar(@{$partdata->{'ResponseTypes'}});$i++){
                     my $respid = $partdata->{'ResponseIds'}->[$i];                      my $respid = $partdata->{'ResponseIds'}->[$i];
                     my $resptype = $partdata->{'ResponseTypes'}->[$i];                      my $resptype = $partdata->{'ResponseTypes'}->[$i];
Line 151  sub ProblemSelector { Line 147  sub ProblemSelector {
   $resptype.'</td><td>'.    $resptype.'</td><td>'.
   '<a href="'.$res->{'src'}.'">'.$title.'</a> ';    '<a href="'.$res->{'src'}.'">'.$title.'</a> ';
 #  '<a href="'.$res->{'src'}.'">'.$resptype.' '.$res->{'title'}.'</a> ';  #  '<a href="'.$res->{'src'}.'">'.$resptype.' '.$res->{'title'}.'</a> ';
                         if ($partdata->{'option'} > 1) {                          if (scalar(@{$partdata->{'ResponseIds'}}) > 1) {
                             $seq_str .= &mt('response').' '.$respid;                              $seq_str .= &mt('response').' '.$respid;
                         }                          }
                         $seq_str .= "</td></tr>\n";                          $seq_str .= "</td></tr>\n";
Line 343  sub get_prev_curr_next { Line 339  sub get_prev_curr_next {
     return ($prev,$curr,$next);      return ($prev,$curr,$next);
 }  }
   
   
   #####################################################
   #####################################################
   
   =pod
   
   =item GetStudentAnswers($r,$problem,$Students)
   
   Determines the correct answer for a set of students on a given problem.
   The students answers are stored in the student hashes pointed to by the
   array @$Students under the key 'answer'.
   
   Inputs: $r
   $problem: hash reference containing the keys 'resource', 'part', and 'respid'.
   $Students: reference to array containing student hashes (need 'username', 
       'domain').  
   
   Returns: nothing 
   
   =cut
   
   #####################################################
   #####################################################
   sub GetStudentAnswers {
       my ($r,$problem,$Students) = @_;
       my $c = $r->connection();
       my %Answers;
       my ($resource,$partid,$respid) = ($problem->{'resource'},
                                         $problem->{'part'},
                                         $problem->{'respid'});
       # Read in the cache (if it exists) before we start timing things.
       &Apache::lonstathelpers::ensure_proper_cache($resource->{'symb'});
       # Open progress window
       my %prog_state=&Apache::lonhtmlcommon::Create_PrgWin
           ($r,'Student Answer Compilation Status',
            'Student Answer Compilation Progress', scalar(@$Students));
       $r->rflush();
       foreach my $student (@$Students) {
           last if ($c->aborted());
           my $sname = $student->{'username'};
           my $sdom = $student->{'domain'};
           my $answer = &Apache::lonstathelpers::analyze_problem_as_student
               ($resource,$sname,$sdom,$partid,$respid);
           &Apache::lonhtmlcommon::Increment_PrgWin($r,\%prog_state,
                                                    &mt('last student'));
           $student->{'answer'} = $answer;
       }
       &Apache::lonstathelpers::write_answer_cache();
       return if ($c->aborted());
       $r->rflush();
       # close progress window
       &Apache::lonhtmlcommon::Close_PrgWin($r,\%prog_state);
       return;
   }
   
   #####################################################
   #####################################################
   
   =pod
   
   =item analyze_problem_as_student
   
   Analyzes a homework problem for a student and returns the correct answer
   for the student.  Attempts to put together an answer for problem types 
   that do not natively support it.
   
   Inputs: $resource: a resource object
           $sname, $sdom, $partid, $respid
   
   Returns: $answer
   
   If $partid and $respid are specified, $answer is simply a scalar containing
   the correct answer for the response.
   
   If $partid or $respid are undefined, $answer will be a hash reference with
   keys $partid.'.'.$respid.'.answer'.
   
   =cut
   
   #####################################################
   #####################################################
   sub analyze_problem_as_student {
       my ($resource,$sname,$sdom,$partid,$respid) = @_;
       my $returnvalue;
       my $url = $resource->{'src'};
       my $symb = $resource->{'symb'};
       my $answer = &get_from_answer_cache($sname,$sdom,$symb,$partid,$respid);
       if (defined($answer)) {
           return($answer);
       }
       my $courseid = $ENV{'request.course.id'};
       my $Answ=&Apache::lonnet::ssi($url,('grade_target' => 'analyze',
                                           'grade_domain' => $sdom,
                                           'grade_username' => $sname,
                                           'grade_symb' => $symb,
                                           'grade_courseid' => $courseid));
       (my $garbage,$Answ)=split(/_HASH_REF__/,$Answ,2);
       my %Answer=&Apache::lonnet::str2hash($Answ);
       #
       undef($answer);
       foreach my $partid (@{$resource->{'parts'}}) {
           my $partdata = $resource->{'partdata'}->{$partid};
           foreach my $respid (@{$partdata->{'ResponseIds'}}) {
               my $prefix = $partid.'.'.$respid;
               my $key = $prefix.'.answer';
               $answer->{$partid}->{$respid} = &get_answer($prefix,$key,%Answer);
           }
       }
       &store_answer($sname,$sdom,$symb,undef,undef,$answer);
       if (! defined($partid)) {
           $returnvalue = $answer;
       } elsif (! defined($respid)) {
           $returnvalue = $answer->{$partid};
       } else {
           $returnvalue = $answer->{$partid}->{$respid};
       }
       return $returnvalue;
   }
   
   sub get_answer {
       my ($prefix,$key,%Answer) = @_;
       my $returnvalue;
       if (exists($Answer{$key})) {
           my $student_answer = $Answer{$key}->[0];
           if (! defined($student_answer)) {
               $student_answer = $Answer{$key}->[1];
           }
           $returnvalue = $student_answer;
       } else {
           if (exists($Answer{$prefix.'.shown'})) {
               # The response has foils
               my %values;
               while (my ($k,$v) = each(%Answer)) {
                   next if ($k !~ /^$prefix\.foil\.(value|area)\.(.*)$/);
                   my $foilname = $2;
                   $values{$foilname}=$v;
               }
               foreach my $foil (@{$Answer{$prefix.'.shown'}}) {
                   if (ref($values{$foil}) eq 'ARRAY') {
                       $returnvalue.=&HTML::Entities::encode($foil,'<>&"').'='.
                           join(',',map {&HTML::Entities::encode($_,'<>&"')} @{$values{$foil}}).'&';
                   } else {
                       $returnvalue.=&HTML::Entities::encode($foil,'<>&"').'='.
                           &HTML::Entities::encode($values{$foil},'<>&"').'&';
                   }
               }
               $returnvalue =~ s/ /\%20/g;
               chop ($returnvalue);
           }
       }
       return $returnvalue;
   }
   
   
   #####################################################
   #####################################################
   
   =pod
   
   =item Caching routines
   
   =over 4
   
   =item &load_answer_cache($symb)
   
   Loads the cache for the given symb into memory from disk.  
   Requires the cache filename be set.  
   Only should be called by &ensure_proper_cache.
   
   =cut
   
   #####################################################
   #####################################################
   {
       my $cache_filename = undef;
       my $current_symb = undef;
       my %cache;
   
   sub load_answer_cache {
       my ($symb) = @_;
       return if (! defined($cache_filename));
       if (! defined($current_symb) || $current_symb ne $symb) {
           undef(%cache);
           my $storedstring;
           my %cache_db;
           if (tie(%cache_db,'GDBM_File',$cache_filename,&GDBM_READER(),0640)) {
               $storedstring = $cache_db{&Apache::lonnet::escape($symb)};
               untie(%cache_db);
           }
           if (defined($storedstring)) {
               %cache = %{thaw($storedstring)};
           }
       }
       return;
   }
   
   #####################################################
   #####################################################
   
   =pod
   
   =item &get_from_answer_cache($sname,$sdom,$symb,$partid,$respid)
   
   Returns the appropriate data from the cache, or undef if no data exists.
   If $respid is undefined, a hash ref containing the answers for the given 
   $partid is returned.  If $partid is undefined, a hash ref containing answers
   for all of the parts is returned.
   
   =cut
   
   #####################################################
   #####################################################
   sub get_from_answer_cache {
       my ($sname,$sdom,$symb,$partid,$respid) = @_;
       &ensure_proper_cache($symb);
       my $returnvalue;
       if (exists($cache{$sname.':'.$sdom}) &&
           ref($cache{$sname.':'.$sdom}) eq 'HASH') {
           if (defined($partid) &&
               exists($cache{$sname.':'.$sdom}->{$partid})) {
               if (defined($respid) &&
                   exists($cache{$sname.':'.$sdom}->{$partid}->{$respid})) {
                   $returnvalue = $cache{$sname.':'.$sdom}->{$partid}->{$respid};
               } else {
                   $returnvalue = $cache{$sname.':'.$sdom}->{$partid};
               }
           } else {
               $returnvalue = $cache{$sname.':'.$sdom};
           }
       } else {
           $returnvalue = undef;
       }
       return $returnvalue;
   }
   
   #####################################################
   #####################################################
   
   =pod
   
   =item &write_answer_cache($symb)
   
   Writes the in memory cache to disk so that it can be read in with
   &load_answer_cache($symb).
   
   =cut
   
   #####################################################
   #####################################################
   sub write_answer_cache {
       return if (! defined($current_symb) || ! defined($cache_filename));
       my %cache_db;
       my $key = &Apache::lonnet::escape($current_symb);
       if (tie(%cache_db,'GDBM_File',$cache_filename,&GDBM_WRCREAT(),0640)) {
           my $storestring = freeze(\%cache);
           $cache_db{$key}=$storestring;
           $cache_db{$key.'.time'}=time;
           untie(%cache_db);
       }
       undef(%cache);
       undef($current_symb);
       undef($cache_filename);
       return;
   }
   
   #####################################################
   #####################################################
   
   =pod
   
   =item &ensure_proper_cache($symb)
   
   Called to make sure we have the proper cache set up.  This is called
   prior to every answer lookup.
   
   =cut
   
   #####################################################
   #####################################################
   sub ensure_proper_cache {
       my ($symb) = @_;
       my $cid = $ENV{'request.course.id'};
       my $new_filename =  '/home/httpd/perl/tmp/'.
           'problemanalsysis_'.$cid.'answer_cache.db';
       if (! defined($cache_filename) ||
           $cache_filename ne $new_filename ||
           ! defined($current_symb)   ||
           $current_symb ne $symb) {
           $cache_filename = $new_filename;
           # Notice: $current_symb is not set to $symb until after the cache is
           # loaded.  This is what tells &load_answer_cache to load in a new
           # symb cache.
           &load_answer_cache($symb);
           $current_symb = $symb;
       }
   }
   
   #####################################################
   #####################################################
   
   =pod
   
   =item &store_answer($sname,$sdom,$symb,$partid,$respid,$dataset)
   
   Stores the answer data in the in memory cache.
   
   =cut
   
   #####################################################
   #####################################################
   sub store_answer {
       my ($sname,$sdom,$symb,$partid,$respid,$dataset) = @_;
       return if ($symb ne $current_symb);
       if (defined($partid)) {
           if (defined($respid)) {
               $cache{$sname.':'.$sdom}->{$partid}->{$respid} = $dataset;
           } else {
               $cache{$sname.':'.$sdom}->{$partid} = $dataset;
           }
       } else {
           $cache{$sname.':'.$sdom}=$dataset;
       }
       return;
   }
   
   }
   #####################################################
   #####################################################
   
   =pod
   
   =back
   
   =cut
   
   #####################################################
   #####################################################
   
   ##
   ## The following is copied from datecalc1.pl, part of the 
   ## Spreadsheet::WriteExcel CPAN module.
   ##
   ##
   ######################################################################
   #
   # Demonstration of writing date/time cells to Excel spreadsheets,
   # using UNIX/Perl time as source of date/time.
   #
   # Copyright 2000, Andrew Benham, adsb@bigfoot.com
   #
   ######################################################################
   #
   # UNIX/Perl time is the time since the Epoch (00:00:00 GMT, 1 Jan 1970)
   # measured in seconds.
   #
   # An Excel file can use exactly one of two different date/time systems.
   # In these systems, a floating point number represents the number of days
   # (and fractional parts of the day) since a start point. The floating point
   # number is referred to as a 'serial'.
   # The two systems ('1900' and '1904') use different starting points:
   #  '1900'; '1.00' is 1 Jan 1900 BUT 1900 is erroneously regarded as
   #          a leap year - see:
   #            http://support.microsoft.com/support/kb/articles/Q181/3/70.asp
   #          for the excuse^H^H^H^H^H^Hreason.
   #  '1904'; '1.00' is 2 Jan 1904.
   #
   # The '1904' system is the default for Apple Macs. Windows versions of
   # Excel have the option to use the '1904' system.
   #
   # Note that Visual Basic's "DateSerial" function does NOT erroneously
   # regard 1900 as a leap year, and thus its serials do not agree with
   # the 1900 serials of Excel for dates before 1 Mar 1900.
   #
   # Note that StarOffice (at least at version 5.2) does NOT erroneously
   # regard 1900 as a leap year, and thus its serials do not agree with
   # the 1900 serials of Excel for dates before 1 Mar 1900.
   #
   ######################################################################
   #
   # Calculation description
   # =======================
   #
   # 1900 system
   # -----------
   # Unix time is '0' at 00:00:00 GMT 1 Jan 1970, i.e. 70 years after 1 Jan 1900.
   # Of those 70 years, 17 (1904,08,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68)
   # were leap years with an extra day.
   # Thus there were 17 + 70*365 days = 25567 days between 1 Jan 1900 and
   # 1 Jan 1970.
   # In the 1900 system, '1' is 1 Jan 1900, but as 1900 was not a leap year
   # 1 Jan 1900 should really be '2', so 1 Jan 1970 is '25569'.
   #
   # 1904 system
   # -----------
   # Unix time is '0' at 00:00:00 GMT 1 Jan 1970, i.e. 66 years after 1 Jan 1904.
   # Of those 66 years, 17 (1904,08,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68)
   # were leap years with an extra day.
   # Thus there were 17 + 66*365 days = 24107 days between 1 Jan 1904 and
   # 1 Jan 1970.
   # In the 1904 system, 2 Jan 1904 being '1', 1 Jan 1970 is '24107'.
   #
   ######################################################################
   #
   # Copyright (c) 2000, Andrew Benham.
   # This program is free software. It may be used, redistributed and/or
   # modified under the same terms as Perl itself.
   #
   # Andrew Benham, adsb@bigfoot.com
   # London, United Kingdom
   # 11 Nov 2000
   #
   ######################################################################
   #-----------------------------------------------------------
   # calc_serial()
   #
   # Called with (up to) 2 parameters.
   #   1.  Unix timestamp.  If omitted, uses current time.
   #   2.  GMT flag. Set to '1' to return serial in GMT.
   #       If omitted, returns serial in appropriate timezone.
   #
   # Returns date/time serial according to $DATE_SYSTEM selected
   #-----------------------------------------------------------
   sub calc_serial {
       # Use 1900 date system on all platforms other than Apple Mac (for which
       # use 1904 date system).
       my $DATE_SYSTEM = ($^O eq 'MacOS') ? 1 : 0;
       my $time = (defined $_[0]) ? $_[0] : time();
       my $gmtflag = (defined $_[1]) ? $_[1] : 0;
       #
       # Divide timestamp by number of seconds in a day.
       # This gives a date serial with '0' on 1 Jan 1970.
       my $serial = $time / 86400;
       #
       # Adjust the date serial by the offset appropriate to the
       # currently selected system (1900/1904).
       if ($DATE_SYSTEM == 0) {        # use 1900 system
           $serial += 25569;
       } else {                        # use 1904 system
           $serial += 24107;
       }
       #
       unless ($gmtflag) {
           # Now have a 'raw' serial with the right offset. But this
           # gives a serial in GMT, which is false unless the timezone
           # is GMT. We need to adjust the serial by the appropriate
           # timezone offset.
           # Calculate the appropriate timezone offset by seeing what
           # the differences between localtime and gmtime for the given
           # time are.
           #    
           my @gmtime = gmtime($time);
           my @ltime  = localtime($time);
           #
           # For the first 7 elements of the two arrays, adjust the
           # date serial where the elements differ.
           for (0 .. 6) {
               my $diff = $ltime[$_] - $gmtime[$_];
               if ($diff) {
                   $serial += _adjustment($diff,$_);
               }
           }
       }
       #
       # Perpetuate the error that 1900 was a leap year by decrementing
       # the serial if we're using the 1900 system and the date is prior to
       # 1 Mar 1900. This has the effect of making serial value '60'
       # 29 Feb 1900.
       #
       # This fix only has any effect if UNIX/Perl time on the platform
       # can represent 1900. Many can't.
       #
       unless ($DATE_SYSTEM) {
           $serial-- if ($serial < 61);    # '61' is 1 Mar 1900
       }
       return $serial;
   }
   
   sub _adjustment {
       # Based on the difference in the localtime/gmtime array elements
       # number, return the adjustment required to the serial.
       #
       # We only look at some elements of the localtime/gmtime arrays:
       #    seconds    unlikely to be different as all known timezones
       #               have an offset of integral multiples of 15 minutes,
       #               but it's easy to do.
       #    minutes    will be different for timezone offsets which are
       #               not an exact number of hours.
       #    hours      very likely to be different.
       #    weekday    will differ when localtime/gmtime difference
       #               straddles midnight.
       #
       # Assume that difference between localtime and gmtime is less than
       # 5 days, then don't have to do maths for day of month, month number,
       # year number, etc...
       #
       my ($delta,$element) = @_;
       my $adjust = 0;
       #
       if ($element == 0) {            # Seconds
           $adjust = $delta/86400;         # 60 * 60 * 24
       } elsif ($element == 1) {       # Minutes
           $adjust = $delta/1440;          # 60 * 24
       } elsif ($element == 2) {       # Hours
           $adjust = $delta/24;            # 24
       } elsif ($element == 6) {       # Day of week number
           # Catch difference straddling Sat/Sun in either direction
           $delta += 7 if ($delta < -4);
           $delta -= 7 if ($delta > 4);
           #    
           $adjust = $delta;
       }
       return $adjust;
   }
   
   ###########################################################
   ###########################################################
   
   =pod
   
   =item get_problem_data
   
   Returns a data structure describing the problem.
   
   Inputs: $url
   
   Returns: %Partdata
   
   =cut
   
   ## note: we must force each foil and option to not begin or end with
   ##       spaces as they are stored without such data.
   ##
   ###########################################################
   ###########################################################
   sub get_problem_data {
       my ($url) = @_;
       my $Answ=&Apache::lonnet::ssi($url,('grade_target' => 'analyze'));
       (my $garbage,$Answ)=split(/_HASH_REF__/,$Answ,2);
       my %Answer;
       %Answer=&Apache::lonnet::str2hash($Answ);
       my %Partdata;
       foreach my $part (@{$Answer{'parts'}}) {
           while (my($key,$value) = each(%Answer)) {
               #
               # Logging code:
               if (0) {
                   &Apache::lonnet::logthis($part.' got key "'.$key.'"');
                   if (ref($value) eq 'ARRAY') {
                       &Apache::lonnet::logthis('    @'.join(',',@$value));
                   } else {
                       &Apache::lonnet::logthis('    '.$value);
                   }
               }
               # End of logging code
               next if ($key !~ /^$part/);
               $key =~ s/^$part\.//;
               if (ref($value) eq 'ARRAY') {
                   if ($key eq 'options') {
                       $Partdata{$part}->{'_Options'}=$value;
                   } elsif ($key eq 'concepts') {
                       $Partdata{$part}->{'_Concepts'}=$value;
                   } elsif ($key =~ /^concept\.(.*)$/) {
                       my $concept = $1;
                       foreach my $foil (@$value) {
                           $Partdata{$part}->{'_Foils'}->{$foil}->{'_Concept'}=
                                                                         $concept;
                       }
                   } elsif ($key =~ /^(incorrect|answer|ans_low|ans_high)$/) {
                       $Partdata{$part}->{$key}=$value;
                   }
               } else {
                   if ($key=~ /^foil\.text\.(.*)$/) {
                       my $foil = $1;
                       $Partdata{$part}->{'_Foils'}->{$foil}->{'name'}=$foil;
                       $value =~ s/(\s*$|^\s*)//g;
                       $Partdata{$part}->{'_Foils'}->{$foil}->{'text'}=$value;
                   } elsif ($key =~ /^foil\.value\.(.*)$/) {
                       my $foil = $1;
                       $Partdata{$part}->{'_Foils'}->{$foil}->{'value'}=$value;
                   }
               }
           }
       }
       return %Partdata;
   }
   
   ####################################################
   ####################################################
   
   =pod
   
   =item &limit_by_time()
   
   =cut
   
   ####################################################
   ####################################################
   sub limit_by_time_form {
       my $Starttime_form = '';
       my $starttime = &Apache::lonhtmlcommon::get_date_from_form
           ('limitby_startdate');
       my $endtime = &Apache::lonhtmlcommon::get_date_from_form
           ('limitby_enddate');
       if (! defined($endtime)) {
           $endtime = time;
       }
       if (! defined($starttime)) {
           $starttime = $endtime - 60*60*24*7;
       }
       my $state;
       if (&limit_by_time()) {
           $state = '';
       } else {
           $state = 'disabled';
       }
       my $startdateform = &Apache::lonhtmlcommon::date_setter
           ('Statistics','limitby_startdate',$starttime,undef,undef,$state);
       my $enddateform = &Apache::lonhtmlcommon::date_setter
           ('Statistics','limitby_enddate',$endtime,undef,undef,$state);
       my $Str;
       $Str .= '<script language="Javascript" >';
       $Str .= 'function toggle_limitby_activity(state) {';
       $Str .= '    if (state) {';
       $Str .= '        limitby_startdate_enable();';
       $Str .= '        limitby_enddate_enable();';
       $Str .= '    } else {';
       $Str .= '        limitby_startdate_disable();';
       $Str .= '        limitby_enddate_disable();';
       $Str .= '    }';    
       $Str .= '}';
       $Str .= '</script>';
       $Str .= '<fieldset>';
       my $timecheckbox = '<input type="checkbox" name="limit_by_time" ';
       if (&limit_by_time()) {
           $timecheckbox .= ' checked ';
       } 
       $timecheckbox .= 'OnChange="javascript:toggle_limitby_activity(this.checked);" ';
       $timecheckbox .= ' />';
       $Str .= '<legend>'.&mt('[_1] Limit by time',$timecheckbox).'</legend>';
       $Str .= &mt('Start Time: [_1]',$startdateform).'<br />';
       $Str .= &mt('&nbsp;End Time: [_1]',$enddateform).'<br />';
       $Str .= '</fieldset>';
       return $Str;
   }
   
   sub limit_by_time {
       if (exists($ENV{'form.limit_by_time'}) &&
           $ENV{'form.limit_by_time'} ne '' ) {
           return 1;
       } else {
           return 0;
       }
   }
   
   sub get_time_limits {
       my $starttime = &Apache::lonhtmlcommon::get_date_from_form
           ('limitby_startdate');
       my $endtime = &Apache::lonhtmlcommon::get_date_from_form
           ('limitby_enddate');
       return ($starttime,$endtime);
   }
   
 ####################################################  ####################################################
 ####################################################  ####################################################
   
Removed from v.1.2  
changed lines
  Added in v.1.10

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>