[BACK]Return to lonuserstate.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / rat

Diff for /rat/lonuserstate.pm between versions 1.149.2.5.2.1 and 1.157

version 1.149.2.5.2.1, 2022/01/02 16:30:29 version 1.157, 2018/11/13 03:59:17
Line 42  use Safe::Hole; Line 42  use Safe::Hole;
 use Opcode;  use Opcode;
 use Apache::lonenc;  use Apache::lonenc;
 use Fcntl qw(:flock);  use Fcntl qw(:flock);
 use LONCAPA qw(:DEFAULT :match);    use LONCAPA qw(:DEFAULT :match);
 use File::Basename;  use File::Basename;
   
     
Line 62  my %randomorder; # maps to order content Line 62  my %randomorder; # maps to order content
 my %randomizationcode; # code used to grade folder for bubblesheet exam   my %randomizationcode; # code used to grade folder for bubblesheet exam 
 my %encurl; # URLs in this folder are supposed to be encrypted  my %encurl; # URLs in this folder are supposed to be encrypted
 my %hiddenurl; # this URL (or complete folder) is supposed to be hidden  my %hiddenurl; # this URL (or complete folder) is supposed to be hidden
 my %deeplinkout; # this URL (or complete folder) unavailable in deep-link session  my %deeplinkonly; # this URL (or complete folder) is deep-link only
 my %rescount; # count of unhidden items in each map  my %rescount; # count of unhidden items in each map
 my %mapcount; # count of unhidden maps in each map  my %mapcount; # count of unhidden maps in each map
   
Line 256  sub loadmap { Line 256  sub loadmap {
  push(@map_ids, $resource_id);   push(@map_ids, $resource_id);
                 if ($hash{'src_'.$lpc.'.'.$resource_id}) {                  if ($hash{'src_'.$lpc.'.'.$resource_id}) {
                     $rescount{$lpc} ++;                      $rescount{$lpc} ++;
                     if (($hash{'src_'.$lpc.'.'.$resource_id}=~/\.sequence$/) ||                      if (($hash{'src_'.$lpc.'.'.$resource_id}=~/\.sequence$/) || 
                         ($hash{'src_'.$lpc.'.'.$resource_id}=~/\.page$/)) {                          ($hash{'src_'.$lpc.'.'.$resource_id}=~/\.page$/)) {
                         $mapcount{$lpc} ++;                          $mapcount{$lpc} ++; 
                     }                      }
                 }                  }
                 unless ($codechecked) {                  unless ($codechecked) {
Line 293  sub loadmap { Line 293  sub loadmap {
     # Handle randomization and random selection      # Handle randomization and random selection
   
     if ($randomize) {      if ($randomize) {
         unless (&is_advanced($courseid)) {          my $advanced;
           if ($env{'request.course.id'}) {
               $advanced = (&Apache::lonnet::allowed('adv') eq 'F');
           } else {
               $env{'request.course.id'} = $courseid;
               $advanced = (&Apache::lonnet::allowed('adv') eq 'F');
               $env{'request.course.id'} = '';
           }
           unless ($advanced) {
             # Order of resources is not randomized if user has and advanced role in the course.              # Order of resources is not randomized if user has and advanced role in the course.
     my $seed;      my $seed;
   
Line 376  sub loadmap { Line 384  sub loadmap {
     }      }
 }  }
   
 sub is_advanced {  
     my ($courseid) = @_;  
     my $advanced;  
     if ($env{'request.course.id'}) {  
         $advanced = (&Apache::lonnet::allowed('adv') eq 'F');  
     } else {  
         $env{'request.course.id'} = $courseid;  
         $advanced = (&Apache::lonnet::allowed('adv') eq 'F');  
         $env{'request.course.id'} = '';  
     }  
     return $advanced;  
 }  
   
 # -------------------------------------------------------------------- Resource  # -------------------------------------------------------------------- Resource
 #  #
Line 474  sub parse_resource { Line 470  sub parse_resource {
     # is not a page.  If the resource is a page then it must be      # is not a page.  If the resource is a page then it must be
     # assembled (at fetch time?).      # assembled (at fetch time?).
   
     if ($ispage) {      unless ($ispage) {
         if ($token->[2]->{'external'} eq 'true') { # external  
             $turi=~s{^http\://}{/ext/};  
         }  
     } else {  
  $turi=~/\.(\w+)$/;   $turi=~/\.(\w+)$/;
  my $embstyle=&Apache::loncommon::fileembstyle($1);   my $embstyle=&Apache::loncommon::fileembstyle($1);
  if ($token->[2]->{'external'} eq 'true') { # external   if ($token->[2]->{'external'} eq 'true') { # external
Line 570  sub parse_resource { Line 562  sub parse_resource {
     if (($turi=~/\.sequence$/) ||      if (($turi=~/\.sequence$/) ||
  ($turi=~/\.page$/)) {   ($turi=~/\.page$/)) {
  $hash{'is_map_'.$rid}=1;   $hash{'is_map_'.$rid}=1;
  if ((!$hiddenurl{$rid}) || (&is_advanced($courseid))) {   &loadmap($turi,$rid,$courseid);
     &loadmap($turi,$rid,$courseid);  
  }  
     }       } 
     return $token->[2]->{'id'};      return $token->[2]->{'id'};
 }  }
Line 905  sub simplify { Line 895  sub simplify {
 #    new value indicating how far the map has been traversed (the sofar).  #    new value indicating how far the map has been traversed (the sofar).
 #  #
 sub traceroute {  sub traceroute {
     my ($sofar,$rid,$beenhere,$encflag,$hdnflag,$cid)=@_;      my ($sofar,$rid,$beenhere,$encflag,$hdnflag)=@_;
     my $newsofar=$sofar=simplify($sofar);      my $newsofar=$sofar=simplify($sofar);
   
     unless ($beenhere=~/\&\Q$rid\E\&/) {      unless ($beenhere=~/\&\Q$rid\E\&/) {
Line 928  sub traceroute { Line 918  sub traceroute {
     && ($hash{'src_'.$rid}!~/\.sequence$/)) {      && ($hash{'src_'.$rid}!~/\.sequence$/)) {
     $retfrid=$rid;      $retfrid=$rid;
  }   }
           my @deeplink=&Apache::lonnet::EXT('resource.0.deeplink',$symb);
         my (@deeplink,@recurseup);          unless ((@deeplink == 0) || ($deeplink[0] eq 'full')) {
         if ($hash{'is_map_'.$rid}) {              $deeplinkonly{$rid}=join(':',@deeplink);
             my ($cdom,$cnum) = split(/_/,$cid);              if ($deeplink[1] eq 'map') {
             my $mapsrc = $hash{'src_'.$rid};                  my $parent = (split(/\,/,$hash{'map_hierarchy_'.$mapid}))[-1];
             my $map_pc = $hash{'map_pc_'.$mapsrc};                  $deeplinkonly{"$parent.$mapid"}=$deeplinkonly{$rid};
             my @pcs = split(/,/,$hash{'map_hierarchy_'.$map_pc});  
             shift(@pcs);  
             @recurseup = map { &Apache::lonnet::declutter($hash{'map_id_'.$_}) } reverse(@pcs);  
             my $mapname = &Apache::lonnet::declutter(&Apache::lonnet::deversion($mapsrc));  
             my $deeplinkval = &get_mapparam($env{'user.name'},$env{'user.domain'},$cnum,$cdom,  
                                             $rid,$mapname,'0.deeplink',\@recurseup);  
             if ($deeplinkval ne '') {  
                 @deeplink = ($deeplinkval,'map');  
             }              }
         } else {  
             my @pcs = split(/,/,$hash{'map_hierarchy_'.$mapid});  
             shift(@pcs);  
             @recurseup = map { &Apache::lonnet::declutter($hash{'map_id_'.$_}) } reverse(@pcs);  
             @deeplink = &Apache::lonnet::EXT('resource.0.deeplink',$symb,'','','','',$cid,\@recurseup);  
         }  
         unless (@deeplink < 2) {  
             $hash{'deeplinkonly_'.$rid}=join(':',map { &escape($_); } @deeplink);  
         }          }
   
  if (defined($hash{'conditions_'.$rid})) {   if (defined($hash{'conditions_'.$rid})) {
Line 974  sub traceroute { Line 948  sub traceroute {
  $hash{'map_start_'.$hash{'src_'.$rid}},   $hash{'map_start_'.$hash{'src_'.$rid}},
  $beenhere,   $beenhere,
  $encflag || $encurl{$rid},   $encflag || $encurl{$rid},
  $hdnflag || $hiddenurl{$rid},   $hdnflag || $hiddenurl{$rid});
                                 $cid);  
     }      }
  }   }
   
Line 1002  sub traceroute { Line 975  sub traceroute {
                 }                  }
  #  Recurse to resoruces that have to's to us.   #  Recurse to resoruces that have to's to us.
                 $newsofar=&traceroute($further,$hash{'goesto_'.$id},$beenhere,                  $newsofar=&traceroute($further,$hash{'goesto_'.$id},$beenhere,
       $encflag,$hdnflag,$cid);        $encflag,$hdnflag);
     }      }
  }   }
     }      }
Line 1199  sub hiddenurls { Line 1172  sub hiddenurls {
     }      }
 }  }
   
 sub deeplinkouts {  
     my $deeplinkoutentry;  
     foreach my $rid (keys(%deeplinkout)) {  
         $hash{'deeplinkout_'.$rid}=1;  
         my ($mapid,$resid)=split(/\./,$rid);  
         $deeplinkoutentry.='&'.  
             &Apache::lonnet::encode_symb($hash{'map_id_'.$mapid},$resid,  
                                          $hash{'src_'.$rid}).'&';  
     }  
 # --------------------------------------- append deeplinkout entry to environment  
     if ($deeplinkoutentry) {  
         &Apache::lonnet::appenv({'acc.deeplinkout' => $deeplinkoutentry});  
     }  
 }  
   
 # -------------------------------------- populate big hash with map breadcrumbs  # -------------------------------------- populate big hash with map breadcrumbs
   
 # Create map_breadcrumbs_$pc from map_hierarchy_$pc by omitting intermediate  # Create map_breadcrumbs_$pc from map_hierarchy_$pc by omitting intermediate
 # maps not shown in Course Contents table.  # maps not shown in Course Contents table.
   
 sub mapcrumbs {  sub mapcrumbs {
     my ($cid) = @_;  
     foreach my $key (keys(%rescount)) {      foreach my $key (keys(%rescount)) {
         if ($hash{'map_hierarchy_'.$key}) {          if ($hash{'map_hierarchy_'.$key}) {
             my $skipnext = 0;              my $skipnext = 0;
             foreach my $id (split(/,/,$hash{'map_hierarchy_'.$key}),$key) {              foreach my $id (split(/,/,$hash{'map_hierarchy_'.$key}),$key) {
                 my $rid = $hash{'ids_'.$hash{'map_id_'.$id}};                  unless ($skipnext) {
                 unless (($skipnext) || (!&is_advanced($cid) && $hash{'deeplinkout_'.$rid})) {  
                     $hash{'map_breadcrumbs_'.$key} .= "$id,";                      $hash{'map_breadcrumbs_'.$key} .= "$id,";
                 }                  }
                 unless (($id == 0) || ($id == 1)) {                  unless (($id == 0) || ($id == 1)) {
Line 1245  sub mapcrumbs { Line 1201  sub mapcrumbs {
 # ---------------------------------------------------- Read map and all submaps  # ---------------------------------------------------- Read map and all submaps
   
 sub readmap {  sub readmap {
     my ($short,$critmsg_check) = @_;      my $short=shift;
     $short=~s/^\///;      $short=~s/^\///;
   
     # TODO:  Hidden dependency on current user:      # TODO:  Hidden dependency on current user:
Line 1285  sub readmap { Line 1241  sub readmap {
     undef %randomizationcode;      undef %randomizationcode;
     undef %hiddenurl;      undef %hiddenurl;
     undef %encurl;      undef %encurl;
     undef %deeplinkout;      undef %deeplinkonly;
     undef %rescount;      undef %rescount;
     undef %mapcount;      undef %mapcount;
     $retfrid='';      $retfrid='';
Line 1434  sub readmap { Line 1390  sub readmap {
         undef %randomizationcode;          undef %randomizationcode;
         undef %hiddenurl;          undef %hiddenurl;
         undef %encurl;          undef %encurl;
         undef %deeplinkout;          undef %deeplinkonly;
         undef %rescount;          undef %rescount;
         undef %mapcount;          undef %mapcount;
         $errtext='';          $errtext='';
Line 1484  sub readmap { Line 1440  sub readmap {
   
 #  Depends on user must parameterize this as well..or separate as this is:  #  Depends on user must parameterize this as well..or separate as this is:
 #  more part of determining what someone sees on entering a course?  #  more part of determining what someone sees on entering a course?
 #  When lonuserstate::readmap() is called from lonroles.pm, i.e.,  
 #  after selecting a role in a course, critical_redirect will be called,  
 #  unless the course has a blocking event in effect, which suppresses  
 #  critical message checking (users without evb priv).  
 #  
   
     if ($critmsg_check) {      my @what=&Apache::lonnet::dump('critical',$env{'user.domain'},
         my ($redirect,$url) = &Apache::loncommon::critical_redirect();     $env{'user.name'});
         if ($redirect) {      if ($what[0]) {
             $retfurl = $url;   if (($what[0] ne 'con_lost') && ($what[0]!~/^error\:/)) {
       $retfurl='/adm/email?critical=display';
         }          }
     }       }
     return ($retfurl,$errtext);      return ($retfurl,$errtext);
 }  }
   
Line 1543  sub build_tmp_hashes { Line 1495  sub build_tmp_hashes {
     # Load the map.. note that loadmap may implicitly recurse if the map contains       # Load the map.. note that loadmap may implicitly recurse if the map contains 
     # sub-maps.      # sub-maps.
   
   
     &loadmap($uri,'0.0',$short);      &loadmap($uri,'0.0',$short);
   
     #  The code below only executes if there is a starting point for the map>      #  The code below only executes if there is a starting point for the map>
Line 1555  sub build_tmp_hashes { Line 1508  sub build_tmp_hashes {
                                  "request.course.uri" => $uri,                                   "request.course.uri" => $uri,
                                  "request.course.tied" => time});                                   "request.course.tied" => time});
         $env{'request.course.id'}=$short;          $env{'request.course.id'}=$short;
         &traceroute('0',$hash{'map_start_'.$uri},'&','','',$short);          &traceroute('0',$hash{'map_start_'.$uri},'&');
         &accinit($uri,$short,$fn);          &accinit($uri,$short,$fn);
         &hiddenurls();          &hiddenurls();
           &mapcrumbs();
     }      }
     $errtext .= &get_mapalias_errors();      $errtext .= &get_mapalias_errors();
 # ------------------------------------------------------- Put versions into src  # ------------------------------------------------------- Put versions into src
Line 1575  sub build_tmp_hashes { Line 1529  sub build_tmp_hashes {
 #           $hash{'src_'.$id}=&Apache::lonenc::encrypted($hash{'src_'.$id});  #           $hash{'src_'.$id}=&Apache::lonenc::encrypted($hash{'src_'.$id});
         $hash{'encrypted_'.$id}=1;          $hash{'encrypted_'.$id}=1;
     }      }
   # ------------------------------------------------------------ Deep-linked URLs
       foreach my $id (keys(%deeplinkonly)) {
           $hash{'deeplinkonly_'.$id}=$deeplinkonly{$id};
       }
 # ----------------------------------------------- Close hashes to finally store  # ----------------------------------------------- Close hashes to finally store
 # --------------------------------- Routine must pass this point, no early outs  # --------------------------------- Routine must pass this point, no early outs
     $hash{'first_rid'}=$retfrid;      $hash{'first_rid'}=$retfrid;
Line 1597  sub build_tmp_hashes { Line 1555  sub build_tmp_hashes {
                                      "Could not write statemap $fn for $uri.</font>");                                       "Could not write statemap $fn for $uri.</font>");
         }          }
     }      }
   
     # Was initial access via a deep-link?  
     my ($cdom,$cnum) = split(/_/,$short);  
     if (($cdom ne '') && ($env{'request.deeplink.login'} ne '')) {  
         my $deeplink_symb = &Apache::loncommon::deeplink_login_symb($cnum,$cdom);  
         if ($deeplink_symb) {  
             my ($loginrid,$deeplink_login_pc,$login_hierarchy);  
             my ($map,$resid,$url) = &Apache::lonnet::decode_symb($deeplink_symb);  
             $loginrid = $hash{'map_pc_'.&Apache::lonnet::clutter($map)}.'.'.$resid;  
             if ($deeplink_symb =~ /\.(page|sequence)$/) {  
                 $deeplink_login_pc = $hash{'map_pc_'.&Apache::lonnet::clutter($url)};  
             } else {  
                 $deeplink_login_pc = $hash{'map_pc_'.&Apache::lonnet::clutter($map)};  
             }  
             my $deeplink;  
             if ($hash{'deeplinkonly_'.$loginrid} ne '') {  
                 my @deeplinkinfo = map { &unescape($_); } split(/:/,$hash{'deeplinkonly_'.$loginrid});  
                 unless (@deeplinkinfo < 2) {  
                     $deeplink = $deeplinkinfo[0];  
                 }  
             }  
             if ($deeplink) {  
                 my $disallow;  
                 my ($state,$others,$listed,$scope,$protect) = split(/,/,$deeplink);  
                 if (($protect ne 'none') && ($protect ne '')) {  
                     my ($acctype,$item) = split(/:/,$protect);  
                     if ($acctype =~ /lti(c|d)$/) {  
                         unless ($env{'request.linkprot'} eq $item.$1.':'.$env{'request.deeplink.login'}) {  
                             $disallow = 1;  
                         }  
                     } elsif ($acctype eq 'key') {  
                         unless ($env{'request.linkkey'} eq $item) {  
                             $disallow = 1;  
                         }  
                     }  
                 }  
                 if ($disallow) {  
                     &Apache::lonnet::delenv('request.deeplink.login');  
                 } else {  
                     if ($others eq 'hide') {  
                         my @recfolders;  
                         if ($scope eq 'rec') {  
                             foreach my $key (keys(%hash)) {  
                                 if ($key=~/^map_hierarchy_(\d+)$/) {  
                                     my $mpc = $1;  
                                     my @ids = split(/,/,$hash{$key});  
                                     if (grep(/^$deeplink_login_pc$/,@ids)) {  
                                         my $idx;  
                                         foreach my $mapid (@ids) {  
                                             if ($idx) {  
                                                 push(@recfolders,$mapid);  
                                             } elsif ($mapid == $deeplink_login_pc) {  
                                                 push(@recfolders,$mapid);  
                                                 $idx = $mapid;  
                                             }  
                                         }  
                                         push(@recfolders,$mpc);  
                                     }  
                                 }  
                             }  
                         }  
                         foreach my $key (keys(%hash)) {  
                             if ($key=~/^src_(.+)$/) {  
                                 my $rid = $1;  
                                 next if ($rid eq '0.0');  
                                 next if ($rid eq $loginrid);  
                                 if ($scope ne 'res') {  
                                     my $mapid = (split(/\./,$rid))[0];  
                                     next if ($mapid eq $deeplink_login_pc);  
                                     if ($scope eq 'rec') {  
                                         next if (grep(/^$mapid$/,@recfolders));  
                                     }  
                                 }  
                                 $deeplinkout{$rid} = 1;  
                             }  
                         }  
                     }  
                 }  
                 &deeplinkouts();  
             }  
         }  
     }  
     &mapcrumbs();  
     return $gotstate;      return $gotstate;
 }  }
   
Line 1741  sub evalstate { Line 1616  sub evalstate {
     return $state;      return $state;
 }  }
   
 sub get_mapparam {  
     my ($uname,$udom,$cnum,$cdom,$rid,$mapname,$what,$recurseupref) = @_;  
     unless ($mapname) { return; }  
   
 # ------------------------------------------------- Get coursedata (if present)  
     my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);  
     if (!ref($courseopt)) {  
         undef($courseopt);  
     }  
   
 # --------------------------------------------------- Get userdata (if present)  
     my $useropt=&Apache::lonnet::get_userresdata($uname,$udom);  
     if (!ref($useropt)) {  
         undef($useropt);  
     }  
   
     my @recurseup;  
     if (ref($recurseupref) eq 'ARRAY') {  
         @recurseup = @{$recurseupref};  
     }  
   
     # Get the section if there is one.  
   
     my $cid = $cdom.'_'.$cnum;  
     my $csec=$env{'request.course.sec'};  
     my $cgroup='';  
     my @cgrps=split(/:/,$env{'request.course.groups'});  
     if (@cgrps > 0) {  
         @cgrps = sort(@cgrps);  
         $cgroup = $cgrps[0];  
     }  
   
     my $rwhat=$what;  
     $what=~s/^parameter\_//;  
     $what=~s/\_/\./;  
   
     # Build the hash keys for the lookup:  
   
     my $mapparm=$mapname.'___(all).'.$what;  
     my $recurseparm=$mapname.'___(rec).'.$what;  
     my $usercourseprefix=$cid;  
   
     my $grplevelm    = "$usercourseprefix.[$cgroup].$mapparm";  
     my $seclevelm    = "$usercourseprefix.[$csec].$mapparm";  
     my $courselevelm = "$usercourseprefix.$mapparm";  
   
     my $grpleveli    = "$usercourseprefix.[$cgroup].$recurseparm";  
     my $secleveli    = "$usercourseprefix.[$csec].$recurseparm";  
     my $courseleveli = "$usercourseprefix.$recurseparm";  
   
     # Check per user  
   
     if ($uname and defined($useropt)) {  
         if (defined($$useropt{$courselevelm})) {  
             return $$useropt{$courselevelm};  
         }  
         if (defined($$useropt{$courseleveli})) {  
             return $$useropt{$courseleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;  
             if (defined($$useropt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$useropt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check course -- group  
   
     if ($cgroup ne '' and defined ($courseopt)) {  
         if (defined($$courseopt{$grplevelm})) {  
             return $$courseopt{$grplevelm};  
         }  
         if (defined($$courseopt{$grpleveli})) {  
             return $$courseopt{$grpleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.['.$cgroup.'].'.$item.'___(all).'.$what;  
             if (defined($$courseopt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$courseopt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check course -- section  
   
     if ($csec ne '' and defined($courseopt)) {  
         if (defined($$courseopt{$seclevelm})) {  
             return $$courseopt{$seclevelm};  
         }  
         if (defined($$courseopt{$secleveli})) {  
             return $$courseopt{$secleveli};  
         }  
         foreach my $item (@recurseup) {  
             my $norecursechk=$usercourseprefix.'.['.$csec.'].'.$item.'___(all).'.$what;  
             if (defined($$courseopt{$norecursechk})) {  
                 if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                     return $$courseopt{$norecursechk};  
                 } else {  
                     last;  
                 }  
             }  
         }  
     }  
   
     # Check the map parameters themselves:  
   
     if ($hash{'param_'.$rid}) {  
         my @items = split(/\&/,$hash{'param_'.$rid});  
         my $thisparm;  
         foreach my $item (@items) {  
             my ($esctype,$escname,$escvalue) = ($item =~ /^([^:]+):([^=]+)=(.*)$/);  
             my $name = &unescape($escname);  
             my $value = &unescape($escvalue);  
             if ($name eq $what) {  
                 $thisparm = $value;  
                 last;  
             }  
         }  
         if (defined($thisparm)) {  
             return $thisparm;  
         }  
     }  
   
    # Additional course parameters:  
   
     if (defined($courseopt)) {  
         if (defined($$courseopt{$courselevelm})) {  
             return $$courseopt{$courselevelm};  
         }  
   
         if (defined($$courseopt{$courseleveli})) {  
             return $$courseopt{$courseleveli};  
         }  
   
         if (@recurseup) {  
             foreach my $item (@recurseup) {  
                 my $norecursechk=$usercourseprefix.'.'.$item.'___(all).'.$what;  
                 if (defined($$courseopt{$norecursechk})) {  
                     if ($what =~ /\.(encrypturl|hiddenresource)$/) {  
                         return $$courseopt{$norecursechk};  
                     } else {  
                         last;  
                     }  
                 }  
             }  
         }  
     }  
     return undef;  
 }  
   
 #  This block seems to have code to manage/detect doubly defined  #  This block seems to have code to manage/detect doubly defined
 #  aliases in maps.  #  aliases in maps.
   
Removed from v.1.149.2.5.2.1  
changed lines
  Added in v.1.157

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