File:  [LON-CAPA] / loncom / xml / lonxml.pm
Revision 1.252: download - view: text, annotated - select for diffs
Fri May 16 18:34:56 2003 UTC (21 years ago) by bowersj2
Branches: MAIN
CVS tags: HEAD
If we're editing the file, show the filename in the title of the frame,
which will show in the tabs.

(Guy: Please make sure that $ENV{'form.editmode'} is true if and only
if we're in editing mode; I think this is so but I don't want to be
wrong.)

Fixes bug 1448.

    1: # The LearningOnline Network with CAPA
    2: # XML Parser Module 
    3: #
    4: # $Id: lonxml.pm,v 1.252 2003/05/16 18:34:56 bowersj2 Exp $
    5: #
    6: # Copyright Michigan State University Board of Trustees
    7: #
    8: # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
    9: #
   10: # LON-CAPA is free software; you can redistribute it and/or modify
   11: # it under the terms of the GNU General Public License as published by
   12: # the Free Software Foundation; either version 2 of the License, or
   13: # (at your option) any later version.
   14: #
   15: # LON-CAPA is distributed in the hope that it will be useful,
   16: # but WITHOUT ANY WARRANTY; without even the implied warranty of
   17: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   18: # GNU General Public License for more details.
   19: #
   20: # You should have received a copy of the GNU General Public License
   21: # along with LON-CAPA; if not, write to the Free Software
   22: # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   23: #
   24: # /home/httpd/html/adm/gpl.txt
   25: #
   26: # http://www.lon-capa.org/
   27: #
   28: # Copyright for TtHfunc and TtMfunc by Ian Hutchinson. 
   29: # TtHfunc and TtMfunc (the "Code") may be compiled and linked into 
   30: # binary executable programs or libraries distributed by the 
   31: # Michigan State University (the "Licensee"), but any binaries so 
   32: # distributed are hereby licensed only for use in the context
   33: # of a program or computational system for which the Licensee is the 
   34: # primary author or distributor, and which performs substantial 
   35: # additional tasks beyond the translation of (La)TeX into HTML.
   36: # The C source of the Code may not be distributed by the Licensee
   37: # to any other parties under any circumstances.
   38: #
   39: # last modified 06/26/00 by Alexander Sakharuk
   40: # 11/6 Gerd Kortemeyer
   41: # 6/1/1 Gerd Kortemeyer
   42: # 2/21,3/13 Guy
   43: # 3/29,5/4 Gerd Kortemeyer
   44: # 5/26 Gerd Kortemeyer
   45: # 5/27 H. K. Ng
   46: # 6/2,6/3,6/8,6/9 Gerd Kortemeyer
   47: # 6/12,6/13 H. K. Ng
   48: # 6/16 Gerd Kortemeyer
   49: # 7/27 H. K. Ng
   50: # 8/7,8/9,8/10,8/11,8/15,8/16,8/17,8/18,8/20,8/23,8/24 Gerd Kortemeyer
   51: # Guy Albertelli
   52: # 9/26 Gerd Kortemeyer
   53: # Dec Guy Albertelli
   54: # YEAR=2002
   55: # 1/1 Gerd Kortemeyer
   56: # 1/2 Matthew Hall
   57: # 1/3 Gerd Kortemeyer
   58: #
   59: 
   60: package Apache::lonxml; 
   61: use vars 
   62: qw(@pwd @outputstack $redirection $import @extlinks $metamode $evaluate %insertlist @namespace $prevent_entity_encode $errorcount $warningcount);
   63: use strict;
   64: use HTML::LCParser();
   65: use HTML::TreeBuilder();
   66: use HTML::Entities();
   67: use Safe();
   68: use Safe::Hole();
   69: use Math::Cephes();
   70: use Math::Random();
   71: use Opcode();
   72: 
   73: sub register {
   74:   my ($space,@taglist) = @_;
   75:   foreach my $temptag (@taglist) {
   76:     push(@{ $Apache::lonxml::alltags{$temptag} },$space);
   77:   }
   78: }
   79: 
   80: sub deregister {
   81:   my ($space,@taglist) = @_;
   82:   foreach my $temptag (@taglist) {
   83:     my $tempspace = $Apache::lonxml::alltags{$temptag}[-1];
   84:     if ($tempspace eq $space) {
   85:       pop(@{ $Apache::lonxml::alltags{$temptag} });
   86:     }
   87:   }
   88:   #&printalltags();
   89: }
   90: 
   91: use Apache::Constants qw(:common);
   92: use Apache::lontexconvert();
   93: use Apache::style();
   94: use Apache::run();
   95: use Apache::londefdef();
   96: use Apache::scripttag();
   97: use Apache::edit();
   98: use Apache::lonnet();
   99: use Apache::File();
  100: use Apache::loncommon();
  101: use Apache::lonfeedback();
  102: use Apache::lonmsg();
  103: use Apache::loncacc();
  104: 
  105: #==================================================   Main subroutine: xmlparse  
  106: #debugging control, to turn on debugging modify the correct handler
  107: $Apache::lonxml::debug=0;
  108: 
  109: # keeps count of the number of warnings and errors generated in a parse
  110: $warningcount=0;
  111: $errorcount=0;
  112: 
  113: #path to the directory containing the file currently being processed
  114: @pwd=();
  115: 
  116: #these two are used for capturing a subset of the output for later processing,
  117: #don't touch them directly use &startredirection and &endredirection
  118: @outputstack = ();
  119: $redirection = 0;
  120: 
  121: #controls wheter the <import> tag actually does
  122: $import = 1;
  123: @extlinks=();
  124: 
  125: # meta mode is a bit weird only some output is to be turned off
  126: #<output> tag turns metamode off (defined in londefdef.pm)
  127: $metamode = 0;
  128: 
  129: # turns on and of run::evaluate actually derefencing var refs
  130: $evaluate = 1;
  131: 
  132: # data structure for eidt mode, determines what tags can go into what other tags
  133: %insertlist=();
  134: 
  135: # stores the list of active tag namespaces
  136: @namespace=();
  137: 
  138: # if 0 all high ASCII characters will be encoded into HTML Entities
  139: $prevent_entity_encode=0;
  140: 
  141: # has the dynamic menu been updated to know about this resource
  142: $Apache::lonxml::registered=0;
  143: 
  144: # a pointer the the Apache request object
  145: $Apache::lonxml::request='';
  146: 
  147: # a problem number counter, and check on ether it is used
  148: $Apache::lonxml::counter=1;
  149: $Apache::lonxml::counter_changed=0;
  150: 
  151: #internal check on whether to look at style defs
  152: $Apache::lonxml::usestyle=1;
  153: 
  154: sub xmlbegin {
  155:   my $output='';
  156:   if ($ENV{'browser.mathml'}) {
  157:       $output='<?xml version="1.0"?>'
  158:             .'<?xml-stylesheet type="text/css" href="/adm/MathML/mathml.css"?>'
  159:             .'<!DOCTYPE html SYSTEM "/adm/MathML/mathml.dtd" '
  160:             .'[<!ENTITY mathns "http://www.w3.org/1998/Math/MathML">]>'
  161:             .'<html xmlns:math="http://www.w3.org/1998/Math/MathML" ' 
  162: 		.'xmlns="http://www.w3.org/TR/REC-html40">';
  163:   } else {
  164:       $output='<html>';
  165:   }
  166:   return $output;
  167: }
  168: 
  169: sub xmlend {
  170:     my ($discussiononly,$symb)=@_;
  171:     my $discussion='';
  172:     if ($ENV{'request.course.id'}) {
  173:        my $crs='/'.$ENV{'request.course.id'};
  174:        if ($ENV{'request.course.sec'}) {
  175:           $crs.='_'.$ENV{'request.course.sec'};
  176:        }                 
  177:        $crs=~s/\_/\//g;
  178:        my $seeid=&Apache::lonnet::allowed('rin',$crs);
  179:        unless ($symb) {
  180:            $symb=&Apache::lonnet::symbread();
  181:        }
  182:        if ($symb) {
  183:           my %contrib=&Apache::lonnet::restore($symb,$ENV{'request.course.id'},
  184:                      $ENV{'course.'.$ENV{'request.course.id'}.'.domain'},
  185: 		     $ENV{'course.'.$ENV{'request.course.id'}.'.num'});
  186:           if ($contrib{'version'}) {
  187:               unless ($discussiononly) {
  188:                  $discussion.=
  189:                   '<address><hr />';
  190: 	     }
  191:               my $idx;
  192:               for ($idx=1;$idx<=$contrib{'version'};$idx++) {
  193: 		my $hidden=($contrib{'hidden'}=~/\.$idx\./);
  194: 		my $deleted=($contrib{'deleted'}=~/\.$idx\./);
  195: 		unless ((($hidden) && (!$seeid)) || ($deleted)) {
  196:                  my $message=$contrib{$idx.':message'};
  197:                  $message=~s/\n/\<br \/\>/g;
  198: 		 $message=&Apache::lontexconvert::msgtexconverted($message);
  199:                  if ($contrib{$idx.':attachmenturl'}) {
  200:                      my ($fname,$ft)
  201:                         =($contrib{$idx.':attachmenturl'}=~/\/(\w+)\.(\w+)$/);
  202: 		     $message.='<p>Attachment: <a href="'.
  203: 	       &Apache::lonnet::tokenwrapper($contrib{$idx.':attachmenturl'}).
  204:                      '"><tt>'.$fname.'.'.$ft.'</tt></a>';
  205:                  }
  206:                  if ($message) {
  207:                   if ($hidden) {
  208: 		      $message='<font color="#888888">'.$message.'</font>';
  209:                   }
  210:                   my $screenname=&Apache::loncommon::screenname(
  211:                                $contrib{$idx.':sendername'},
  212: 			       $contrib{$idx.':senderdomain'});
  213:                   my $plainname=&Apache::loncommon::nickname(
  214:                                $contrib{$idx.':sendername'},
  215: 			       $contrib{$idx.':senderdomain'});
  216: 
  217:                   my $sender='Anonymous';
  218:                   if ((!$contrib{$idx.':anonymous'}) || ($seeid)) {
  219:                       $sender=&Apache::loncommon::aboutmewrapper(
  220:                                $plainname,
  221:                                $contrib{$idx.':sendername'},
  222:                                $contrib{$idx.':senderdomain'}).' ('.
  223:                               $contrib{$idx.':sendername'}.' at '.
  224: 		      $contrib{$idx.':senderdomain'}.')';
  225:                       if ($contrib{$idx.':anonymous'}) {
  226: 			  $sender.=' [anonymous] '.
  227:                                      $screenname;
  228:                       }
  229:                       if ($seeid) {
  230: 			  if ($hidden) {
  231:                              $sender.=' <a href="/adm/feedback?unhide='.
  232: 				 $symb.':::'.$idx.'">Make Visible</a>';
  233:                           } else {
  234:                              $sender.=' <a href="/adm/feedback?hide='.
  235: 				 $symb.':::'.$idx.'">Hide</a>';
  236: 			  }                     
  237:                           $sender.=' <a href="/adm/feedback?deldisc='.
  238: 				 $symb.':::'.$idx.'">Delete</a>';
  239:                       }
  240:                   } else {
  241:                       if ($screenname) {
  242: 			  $sender='<i>'.$screenname.'</i>';
  243:                       }
  244:                   }
  245: 		  $discussion.='<p><b>'.$sender.'</b> ('.
  246:                       localtime($contrib{$idx.':timestamp'}).
  247:                       '):<blockquote>'.$message.
  248:                       '</blockquote></p>';
  249: 	        }
  250:                } 
  251:               }
  252:               unless ($discussiononly) {
  253:                  $discussion.='</address>';
  254: 	      }
  255:           }
  256:           if ($discussiononly) {
  257: 	      $discussion.=(<<ENDDISCUSS);
  258: <form action="/adm/feedback" method="post" name="mailform" enctype="multipart/form-data">
  259: <input type="submit" name="discuss" value="Post Discussion" />
  260: <input type="submit" name="anondiscuss" value="Post Anonymous Discussion" />
  261: <input type="hidden" name="symb" value="$symb" />
  262: <input type="hidden" name="sendit" value="true" />
  263: <br />
  264: <font size="1">Note: in anonymous discussion, your name is visible only to
  265: course faculty</font><br />
  266: <textarea name=comment cols=60 rows=10 wrap=hard></textarea>
  267: <p>
  268: Attachment (128 KB max size): <input type="file" name="attachment" />
  269: </p>
  270: </form>
  271: ENDDISCUSS
  272:              $discussion.=&Apache::lonfeedback::generate_preview_button();
  273:           }
  274:        }
  275:     }
  276:     return $discussion.($discussiononly?'':'</html>');
  277: }
  278: 
  279: sub tokeninputfield {
  280:     my $defhost=$Apache::lonnet::perlvar{'lonHostID'};
  281:     $defhost=~tr/a-z/A-Z/;
  282:     return (<<ENDINPUTFIELD)
  283: <script type="text/javascript">
  284:     function updatetoken() {
  285: 	var comp=new Array;
  286:         var barcode=unescape(document.tokeninput.barcode.value);
  287:         comp=barcode.split('*');
  288:         if (typeof(comp[0])!="undefined") {
  289: 	    document.tokeninput.codeone.value=comp[0];
  290: 	}
  291:         if (typeof(comp[1])!="undefined") {
  292: 	    document.tokeninput.codetwo.value=comp[1];
  293: 	}
  294:         if (typeof(comp[2])!="undefined") {
  295:             comp[2]=comp[2].toUpperCase();
  296: 	    document.tokeninput.codethree.value=comp[2];
  297: 	}
  298:         document.tokeninput.barcode.value='';
  299:     }  
  300: </script>
  301: <form method="post" name="tokeninput">
  302: <table border="2" bgcolor="#FFFFBB">
  303: <tr><th>DocID Checkin</th></tr>
  304: <tr><td>
  305: <table>
  306: <tr>
  307: <td>Scan in Barcode</td>
  308: <td><input type="text" size="22" name="barcode" 
  309: onChange="updatetoken()"/></td>
  310: </tr>
  311: <tr><td><i>or</i> Type in DocID</td>
  312: <td>
  313: <input type="text" size="5" name="codeone" />
  314: <b><font size="+2">*</font></b>
  315: <input type="text" size="5" name="codetwo" />
  316: <b><font size="+2">*</font></b>
  317: <input type="text" size="10" name="codethree" value="$defhost" 
  318: onChange="this.value=this.value.toUpperCase()" />
  319: </td></tr>
  320: </table>
  321: </td></tr>
  322: <tr><td><input type="submit" value="Check in DocID" /></td></tr>
  323: </table>
  324: </form>
  325: ENDINPUTFIELD
  326: }
  327: 
  328: sub maketoken {
  329:     my ($symb,$tuname,$tudom,$tcrsid)=@_;
  330:     unless ($symb) {
  331: 	$symb=&Apache::lonnet::symbread();
  332:     }
  333:     unless ($tuname) {
  334: 	$tuname=$ENV{'user.name'};
  335:         $tudom=$ENV{'user.domain'};
  336:         $tcrsid=$ENV{'request.course.id'};
  337:     }
  338: 
  339:     return &Apache::lonnet::checkout($symb,$tuname,$tudom,$tcrsid);
  340: }
  341: 
  342: sub printtokenheader {
  343:     my ($target,$token,$tsymb,$tcrsid,$tudom,$tuname)=@_;
  344:     unless ($token) { return ''; }
  345: 
  346:     my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
  347:     unless ($tsymb) {
  348: 	$tsymb=$symb;
  349:     }
  350:     unless ($tuname) {
  351: 	$tuname=$name;
  352:         $tudom=$domain;
  353:         $tcrsid=$courseid;
  354:     }
  355: 
  356:     my %reply=&Apache::lonnet::get('environment',
  357:               ['firstname','middlename','lastname','generation'],
  358:               $tudom,$tuname);
  359:     my $plainname=$reply{'firstname'}.' '. 
  360:                   $reply{'middlename'}.' '.
  361:                   $reply{'lastname'}.' '.
  362: 		  $reply{'generation'};
  363: 
  364:     if ($target eq 'web') {
  365:         my %idhash=&Apache::lonnet::idrget($tudom,($tuname));
  366: 	return 
  367:  '<img align="right" src="/cgi-bin/barcode.png?encode='.$token.'" />'.
  368:                'Checked out for '.$plainname.
  369:                '<br />User: '.$tuname.' at '.$tudom.
  370: 	       '<br />ID: '.$idhash{$tuname}.
  371: 	       '<br />CourseID: '.$tcrsid.
  372: 	       '<br />Course: '.$ENV{'course.'.$tcrsid.'.description'}.
  373:                '<br />DocID: '.$token.
  374:                '<br />Time: '.localtime().'<hr />';
  375:     } else {
  376:         return $token;
  377:     }
  378: }
  379: 
  380: sub fontsettings() {
  381:     my $headerstring='';
  382:     if (($ENV{'browser.os'} eq 'mac') && (!$ENV{'browser.mathml'})) { 
  383: 	$headerstring.=
  384: 	    '<meta Content-Type="text/html; charset=x-mac-roman">';
  385:     } elsif (!$ENV{'browser.mathml'}) {
  386: 	$headerstring.=
  387: 	    '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
  388:     }
  389:     return $headerstring;
  390: }
  391: 
  392: sub printalltags {
  393:   my $temp;
  394:   foreach $temp (sort keys %Apache::lonxml::alltags) {
  395:     &Apache::lonxml::debug("$temp -- ".
  396: 		  join(',',@{ $Apache::lonxml::alltags{$temp} }));
  397:   }
  398: }
  399: 
  400: sub xmlparse {
  401:  my ($request,$target,$content_file_string,$safeinit,%style_for_target) = @_;
  402: 
  403:  &setup_globals($request,$target);
  404:  &Apache::inputtags::initialize_inputtags();
  405:  &Apache::outputtags::initialize_outputtags();
  406:  &Apache::edit::initialize_edit();
  407: 
  408: #
  409: # do we have a course style file?
  410: #
  411: 
  412:  if ($ENV{'request.course.id'} && $ENV{'request.state'} ne 'construct') {
  413:      my $bodytext=
  414: 	 $ENV{'course.'.$ENV{'request.course.id'}.'.default_xml_style'};
  415:      if ($bodytext) {
  416:        my $location=&Apache::lonnet::filelocation('',$bodytext);
  417:        my $styletext=&Apache::lonnet::getfile($location);
  418:        if ($styletext ne '-1') {
  419:           %style_for_target = (%style_for_target,
  420:                           &Apache::style::styleparser($target,$styletext));
  421:        }
  422:     }
  423:  }
  424: 
  425:  #&printalltags();
  426:  my @pars = ();
  427:  my $pwd=$ENV{'request.filename'};
  428:  $pwd =~ s:/[^/]*$::;
  429:  &newparser(\@pars,\$content_file_string,$pwd);
  430: 
  431:  my $safeeval = new Safe;
  432:  my $safehole = new Safe::Hole;
  433:  &init_safespace($target,$safeeval,$safehole,$safeinit);
  434: #-------------------- Redefinition of the target in the case of compound target
  435: 
  436:  ($target, my @tenta) = split('&&',$target);
  437: 
  438:  my @stack = ();
  439:  my @parstack = ();
  440:  &initdepth;
  441: 
  442:  my $finaloutput = &inner_xmlparse($target,\@stack,\@parstack,\@pars,
  443: 				   $safeeval,\%style_for_target);
  444:  if ($ENV{'request.uri'}) {
  445:     &writeallows($ENV{'request.uri'});
  446:  }
  447:  if ($Apache::lonxml::counter_changed) { &store_counter() }
  448:  return $finaloutput;
  449: }
  450: 
  451: sub htmlclean {
  452:     my ($raw,$full)=@_;
  453: 
  454:     my $tree = HTML::TreeBuilder->new;
  455:     $tree->ignore_unknown(0);
  456: 
  457:     $tree->parse($raw);
  458: 
  459:     my $output= $tree->as_HTML(undef,' ');
  460: 
  461:     $output=~s/\<(br|hr|img|meta|allow)(.*?)\>/\<$1$2 \/\>/gis;
  462:     $output=~s/\<\/(br|hr|img|meta|allow)\>//gis;
  463:     unless ($full) {
  464:        $output=~s/\<[\/]*(body|head|html)\>//gis;
  465:     }
  466: 
  467:     $tree = $tree->delete;
  468: 
  469:     return $output;
  470: }
  471: 
  472: sub latex_special_symbols {
  473:     my ($current_token,$stack,$parstack,$where)=@_;
  474:     if ($where eq 'header') {
  475: 	$current_token =~ s/(\\|_|\^)/ /g;
  476: 	$current_token =~ s/(\$|%|\#|&|\{|\})/\\$1/g;
  477:     } else {
  478: 	$current_token=~s/\\ /\\char92 /g;
  479: 	$current_token=~s/\^/\\char94 /g;
  480: 	$current_token=~s/\~/\\char126 /g;
  481: 	$current_token=~s/(&[^A-Za-z\#])/\\$1/g;
  482: 	$current_token=~s/([^&])\#/$1\\#/g;
  483: 	$current_token=~s/(\$|_|{|})/\\$1/g;
  484: 	$current_token=~s/\\char92 /\\texttt{\\char92}/g;
  485: 	$current_token=~s/(>|<)/\$$1\$/g; #more or less
  486: 	if ($current_token=~m/\d%/) {$current_token =~ s/(\d)%/$1\\%/g;} #percent after digit
  487: 	if ($current_token=~m/\s%/) {$current_token =~ s/(\s)%/$1\\%/g;} #persent after space
  488:     }
  489:     return $current_token;
  490: }
  491: 
  492: sub inner_xmlparse {
  493:   my ($target,$stack,$parstack,$pars,$safeeval,$style_for_target)=@_;
  494:   my $finaloutput = '';
  495:   my $result;
  496:   my $token;
  497:   while ( $#$pars > -1 ) {
  498:     while ($token = $$pars['-1']->get_token) {
  499:       if (($token->[0] eq 'T') || ($token->[0] eq 'C') || ($token->[0] eq 'D') ) {
  500: 	if ($metamode<1) {
  501: 	    my $text=$token->[1];
  502: 	    if ($token->[0] eq 'C' && $target eq 'tex') {
  503: 		$text = '';
  504: #		$text = '%'.$text."\n";
  505: 	    }
  506: 	    $result.=$text;
  507: 	}
  508:       } elsif ($token->[0] eq 'PI') {
  509: 	if ($metamode<1) {
  510: 	  $result=$token->[2];
  511: 	}
  512:       } elsif ($token->[0] eq 'S') {
  513: 	# add tag to stack
  514: 	push (@$stack,$token->[1]);
  515: 	# add parameters list to another stack
  516: 	push (@$parstack,&parstring($token));
  517: 	&increasedepth($token);
  518: 	if ($Apache::lonxml::usestyle &&
  519: 	    exists($$style_for_target{$token->[1]})) {
  520: 	    $Apache::lonxml::usestyle=0;
  521: 	    my $string=$$style_for_target{$token->[1]}.
  522: 	      '<LONCAPA_INTERNAL_TURN_STYLE_ON />';
  523: 	    &Apache::lonxml::newparser($pars,\$string);
  524: 	} else {
  525: 	  $result = &callsub("start_$token->[1]", $target, $token, $stack,
  526: 			     $parstack, $pars, $safeeval, $style_for_target);
  527: 	}
  528:       } elsif ($token->[0] eq 'E') {
  529: 	#clear out any tags that didn't end
  530: 	while ($token->[1] ne $$stack['-1'] && ($#$stack > -1)) {
  531: 	  my $lasttag=$$stack[-1];
  532: 	  if ($token->[1] =~ /^$lasttag$/i) {
  533: 	    &Apache::lonxml::warning('Using tag &lt;/'.$token->[1].'&gt; on line '.$token->[3].' as end tag to &lt;'.$$stack[-1].'&gt;');
  534: 	    last;
  535: 	  } else {
  536: 	    &Apache::lonxml::warning('Found tag &lt;/'.$token->[1].'&gt; on line '.$token->[3].' when looking for &lt;/'.$$stack[-1].'&gt; in file');
  537: 	    &end_tag($stack,$parstack,$token);
  538: 	  }
  539: 	}
  540: 
  541: 	if ($Apache::lonxml::usestyle &&
  542: 	    exists($$style_for_target{'/'."$token->[1]"})) {
  543: 	    $Apache::lonxml::usestyle=0;
  544: 	    my $string=$$style_for_target{'/'.$token->[1]}.
  545: 	      '<LONCAPA_INTERNAL_TURN_STYLE_ON />';
  546: 	    &Apache::lonxml::newparser($pars,\$string);
  547: 	} else {
  548: 	  $result = &callsub("end_$token->[1]", $target, $token, $stack,
  549: 			     $parstack, $pars,$safeeval, $style_for_target);
  550: 	}
  551:       } else {
  552: 	&Apache::lonxml::error("Unknown token event :$token->[0]:$token->[1]:");
  553:       }
  554:       #evaluate variable refs in result
  555:       if ($result ne "") {
  556: 	if ( $#$parstack > -1 ) {
  557: 	  $result=&Apache::run::evaluate($result,$safeeval,$$parstack[-1]);
  558: 	} else {
  559: 	  $result= &Apache::run::evaluate($result,$safeeval,'');
  560: 	}
  561:       }
  562:       if (($token->[0] eq 'T') || ($token->[0] eq 'C') || ($token->[0] eq 'D') ) {
  563: 	  #Style file definitions should be correct
  564: 	  if ($target eq 'tex' && ($Apache::lonxml::usestyle)) {
  565: 	      $result=&latex_special_symbols($result,$stack,$parstack);
  566: 	  }
  567:       }
  568: 
  569:       # Encode any high ASCII characters
  570:       if (!$Apache::lonxml::prevent_entity_encode) {
  571: 	$result=&HTML::Entities::encode($result,"\200-\377");
  572:       }
  573:       if ($Apache::lonxml::redirection) {
  574: 	$Apache::lonxml::outputstack['-1'] .= $result;
  575:       } else {
  576: 	$finaloutput.=$result;
  577:       }
  578:       $result = '';
  579: 
  580:       if ($token->[0] eq 'E') { 
  581: 	&end_tag($stack,$parstack,$token);
  582:       }
  583:     }	
  584:     if ($#$pars > -1) {
  585: 	pop @$pars;
  586: 	pop @Apache::lonxml::pwd;
  587:     }
  588:   }
  589: 
  590:   # if ($target eq 'meta') {
  591:   #   $finaloutput.=&endredirection;
  592:   # }
  593: 
  594: 
  595:   if (($ENV{'QUERY_STRING'}) && ($target eq 'web')) {
  596:     $finaloutput=&afterburn($finaloutput);
  597:   }	    
  598:   return $finaloutput;
  599: }
  600: 
  601: sub callsub {
  602:   my ($sub,$target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;
  603:   my $currentstring='';
  604:   my $nodefault;
  605:   {
  606:     my $sub1;
  607:     no strict 'refs';
  608:     my $tag=$token->[1];
  609: # get utterly rid of extended html tags
  610:     if ($tag=~/^x\-/i) { return ''; }
  611:     my $space=$Apache::lonxml::alltags{$tag}[-1];
  612:     if (!$space) {
  613:      	$tag=~tr/A-Z/a-z/;
  614: 	$sub=~tr/A-Z/a-z/;
  615: 	$space=$Apache::lonxml::alltags{$tag}[-1]
  616:     }
  617: 
  618:     my $deleted=0;
  619:     $Apache::lonxml::curdepth=join('_',@Apache::lonxml::depthcounter);
  620:     if (($token->[0] eq 'S') && ($target eq 'modified')) {
  621:       $deleted=&Apache::edit::handle_delete($space,$target,$token,$tagstack,
  622: 					     $parstack,$parser,$safeeval,
  623: 					     $style);
  624:     }
  625:     if (!$deleted) {
  626:       if ($space) {
  627: 	#&Apache::lonxml::debug("Calling sub $sub in $space $metamode");
  628: 	$sub1="$space\:\:$sub";
  629: 	($currentstring,$nodefault) = &$sub1($target,$token,$tagstack,
  630: 					     $parstack,$parser,$safeeval,
  631: 					     $style);
  632:       } else {
  633: 	#&Apache::lonxml::debug("NOT Calling sub $sub in $space $metamode");
  634: 	if ($metamode <1) {
  635: 	  if (defined($token->[4]) && ($metamode < 1)) {
  636: 	    $currentstring = $token->[4];
  637: 	  } else {
  638: 	    $currentstring = $token->[2];
  639: 	  }
  640: 	}
  641:       }
  642:       #    &Apache::lonxml::debug("nodefalt:$nodefault:");
  643:       if ($currentstring eq '' && $nodefault eq '') {
  644: 	if ($target eq 'edit') {
  645: 	  #&Apache::lonxml::debug("doing default edit for $token->[1]");
  646: 	  if ($token->[0] eq 'S') {
  647: 	    $currentstring = &Apache::edit::tag_start($target,$token);
  648: 	  } elsif ($token->[0] eq 'E') {
  649: 	    $currentstring = &Apache::edit::tag_end($target,$token);
  650: 	  }
  651: 	} elsif ($target eq 'modified') {
  652: 	  if ($token->[0] eq 'S') {
  653: 	    $currentstring = $token->[4];
  654: 	    $currentstring.=&Apache::edit::handle_insert();
  655: 	  } elsif ($token->[0] eq 'E') {
  656: 	    $currentstring = $token->[2];
  657:             $currentstring.=&Apache::edit::handle_insertafter($token->[1]);
  658: 	  } else {
  659: 	    $currentstring = $token->[2];
  660: 	  }
  661: 	}
  662:       }
  663:     }
  664:     use strict 'refs';
  665:   }
  666:   return $currentstring;
  667: }
  668: 
  669: sub setup_globals {
  670:   my ($request,$target)=@_;
  671:   $Apache::lonxml::request=$request;
  672:   $Apache::lonxml::registered = 0;
  673:   $errorcount=0;
  674:   $warningcount=0;
  675:   $Apache::lonxml::default_homework_loaded=0;
  676:   $Apache::lonxml::usestyle=1;
  677:   &init_counter();
  678:   @Apache::lonxml::pwd=();
  679:   @Apache::lonxml::extlinks=();
  680:   if ($target eq 'meta') {
  681:     $Apache::lonxml::redirection = 0;
  682:     $Apache::lonxml::metamode = 1;
  683:     $Apache::lonxml::evaluate = 1;
  684:     $Apache::lonxml::import = 0;
  685:   } elsif ($target eq 'answer') {
  686:     $Apache::lonxml::redirection = 0;
  687:     $Apache::lonxml::metamode = 1;
  688:     $Apache::lonxml::evaluate = 1;
  689:     $Apache::lonxml::import = 1;
  690:   } elsif ($target eq 'grade') {
  691:     &startredirection;
  692:     $Apache::lonxml::metamode = 0;
  693:     $Apache::lonxml::evaluate = 1;
  694:     $Apache::lonxml::import = 1;
  695:   } elsif ($target eq 'modified') {
  696:     $Apache::lonxml::redirection = 0;
  697:     $Apache::lonxml::metamode = 0;
  698:     $Apache::lonxml::evaluate = 0;
  699:     $Apache::lonxml::import = 0;
  700:   } elsif ($target eq 'edit') {
  701:     $Apache::lonxml::redirection = 0;
  702:     $Apache::lonxml::metamode = 0;
  703:     $Apache::lonxml::evaluate = 0;
  704:     $Apache::lonxml::import = 0;
  705:   } elsif ($target eq 'analyze') {
  706:     $Apache::lonxml::redirection = 0;
  707:     $Apache::lonxml::metamode = 0;
  708:     $Apache::lonxml::evaluate = 1;
  709:     $Apache::lonxml::import = 1;
  710:   } else {
  711:     $Apache::lonxml::redirection = 0;
  712:     $Apache::lonxml::metamode = 0;
  713:     $Apache::lonxml::evaluate = 1;
  714:     $Apache::lonxml::import = 1;
  715:   }
  716: }
  717: 
  718: sub init_safespace {
  719:   my ($target,$safeeval,$safehole,$safeinit) = @_;
  720:   $safeeval->permit("entereval");
  721:   $safeeval->permit(":base_math");
  722:   $safeeval->permit("sort");
  723:   $safeeval->deny(":base_io");
  724:   $safehole->wrap(\&Apache::scripttag::xmlparse,$safeeval,'&xmlparse');
  725:   $safehole->wrap(\&Apache::outputtags::multipart,$safeeval,'&multipart');
  726:   $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
  727:   
  728:   $safehole->wrap(\&Math::Cephes::asin,$safeeval,'&asin');
  729:   $safehole->wrap(\&Math::Cephes::acos,$safeeval,'&acos');
  730:   $safehole->wrap(\&Math::Cephes::atan,$safeeval,'&atan');
  731:   $safehole->wrap(\&Math::Cephes::sinh,$safeeval,'&sinh');
  732:   $safehole->wrap(\&Math::Cephes::cosh,$safeeval,'&cosh');
  733:   $safehole->wrap(\&Math::Cephes::tanh,$safeeval,'&tanh');
  734:   $safehole->wrap(\&Math::Cephes::asinh,$safeeval,'&asinh');
  735:   $safehole->wrap(\&Math::Cephes::acosh,$safeeval,'&acosh');
  736:   $safehole->wrap(\&Math::Cephes::atanh,$safeeval,'&atanh');
  737:   $safehole->wrap(\&Math::Cephes::erf,$safeeval,'&erf');
  738:   $safehole->wrap(\&Math::Cephes::erfc,$safeeval,'&erfc');
  739:   $safehole->wrap(\&Math::Cephes::j0,$safeeval,'&j0');
  740:   $safehole->wrap(\&Math::Cephes::j1,$safeeval,'&j1');
  741:   $safehole->wrap(\&Math::Cephes::jn,$safeeval,'&jn');
  742:   $safehole->wrap(\&Math::Cephes::jv,$safeeval,'&jv');
  743:   $safehole->wrap(\&Math::Cephes::y0,$safeeval,'&y0');
  744:   $safehole->wrap(\&Math::Cephes::y1,$safeeval,'&y1');
  745:   $safehole->wrap(\&Math::Cephes::yn,$safeeval,'&yn');
  746:   $safehole->wrap(\&Math::Cephes::yv,$safeeval,'&yv');
  747:   
  748:   $safehole->wrap(\&Math::Cephes::bdtr  ,$safeeval,'&bdtr'  );
  749:   $safehole->wrap(\&Math::Cephes::bdtrc ,$safeeval,'&bdtrc' );
  750:   $safehole->wrap(\&Math::Cephes::bdtri ,$safeeval,'&bdtri' );
  751:   $safehole->wrap(\&Math::Cephes::btdtr ,$safeeval,'&btdtr' );
  752:   $safehole->wrap(\&Math::Cephes::chdtr ,$safeeval,'&chdtr' );
  753:   $safehole->wrap(\&Math::Cephes::chdtrc,$safeeval,'&chdtrc');
  754:   $safehole->wrap(\&Math::Cephes::chdtri,$safeeval,'&chdtri');
  755:   $safehole->wrap(\&Math::Cephes::fdtr  ,$safeeval,'&fdtr'  );
  756:   $safehole->wrap(\&Math::Cephes::fdtrc ,$safeeval,'&fdtrc' );
  757:   $safehole->wrap(\&Math::Cephes::fdtri ,$safeeval,'&fdtri' );
  758:   $safehole->wrap(\&Math::Cephes::gdtr  ,$safeeval,'&gdtr'  );
  759:   $safehole->wrap(\&Math::Cephes::gdtrc ,$safeeval,'&gdtrc' );
  760:   $safehole->wrap(\&Math::Cephes::nbdtr ,$safeeval,'&nbdtr' );
  761:   $safehole->wrap(\&Math::Cephes::nbdtrc,$safeeval,'&nbdtrc');
  762:   $safehole->wrap(\&Math::Cephes::nbdtri,$safeeval,'&nbdtri');
  763:   $safehole->wrap(\&Math::Cephes::ndtr  ,$safeeval,'&ndtr'  );
  764:   $safehole->wrap(\&Math::Cephes::ndtri ,$safeeval,'&ndtri' );
  765:   $safehole->wrap(\&Math::Cephes::pdtr  ,$safeeval,'&pdtr'  );
  766:   $safehole->wrap(\&Math::Cephes::pdtrc ,$safeeval,'&pdtrc' );
  767:   $safehole->wrap(\&Math::Cephes::pdtri ,$safeeval,'&pdtri' );
  768:   $safehole->wrap(\&Math::Cephes::stdtr ,$safeeval,'&stdtr' );
  769:   $safehole->wrap(\&Math::Cephes::stdtri,$safeeval,'&stdtri');
  770: 
  771: #  $safehole->wrap(\&Math::Cephes::new_fract,$safeeval,'&new_fract');
  772: #  $safehole->wrap(\&Math::Cephes::radd,$safeeval,'&radd');
  773: #  $safehole->wrap(\&Math::Cephes::rsub,$safeeval,'&rsub');
  774: #  $safehole->wrap(\&Math::Cephes::rmul,$safeeval,'&rmul');
  775: #  $safehole->wrap(\&Math::Cephes::rdiv,$safeeval,'&rdiv');
  776: #  $safehole->wrap(\&Math::Cephes::euclid,$safeeval,'&euclid');
  777: 
  778:   $safehole->wrap(\&Math::Random::random_beta,$safeeval,'&math_random_beta');
  779:   $safehole->wrap(\&Math::Random::random_chi_square,$safeeval,'&math_random_chi_square');
  780:   $safehole->wrap(\&Math::Random::random_exponential,$safeeval,'&math_random_exponential');
  781:   $safehole->wrap(\&Math::Random::random_f,$safeeval,'&math_random_f');
  782:   $safehole->wrap(\&Math::Random::random_gamma,$safeeval,'&math_random_gamma');
  783:   $safehole->wrap(\&Math::Random::random_multivariate_normal,$safeeval,'&math_random_multivariate_normal');
  784:   $safehole->wrap(\&Math::Random::random_multinomial,$safeeval,'&math_random_multinomial');
  785:   $safehole->wrap(\&Math::Random::random_noncentral_chi_square,$safeeval,'&math_random_noncentral_chi_square');
  786:   $safehole->wrap(\&Math::Random::random_noncentral_f,$safeeval,'&math_random_noncentral_f');
  787:   $safehole->wrap(\&Math::Random::random_normal,$safeeval,'&math_random_normal');
  788:   $safehole->wrap(\&Math::Random::random_permutation,$safeeval,'&math_random_permutation');
  789:   $safehole->wrap(\&Math::Random::random_permuted_index,$safeeval,'&math_random_permuted_index');
  790:   $safehole->wrap(\&Math::Random::random_uniform,$safeeval,'&math_random_uniform');
  791:   $safehole->wrap(\&Math::Random::random_poisson,$safeeval,'&math_random_poisson');
  792:   $safehole->wrap(\&Math::Random::random_uniform_integer,$safeeval,'&math_random_uniform_integer');
  793:   $safehole->wrap(\&Math::Random::random_negative_binomial,$safeeval,'&math_random_negative_binomial');
  794:   $safehole->wrap(\&Math::Random::random_binomial,$safeeval,'&math_random_binomial');
  795:   $safehole->wrap(\&Math::Random::random_seed_from_phrase,$safeeval,'&random_seed_from_phrase');
  796:   $safehole->wrap(\&Math::Random::random_set_seed_from_phrase,$safeeval,'&random_set_seed_from_phrase');
  797:   $safehole->wrap(\&Math::Random::random_get_seed,$safeeval,'&random_get_seed');
  798:   $safehole->wrap(\&Math::Random::random_set_seed,$safeeval,'&random_set_seed');
  799: 
  800: #need to inspect this class of ops
  801: # $safeeval->deny(":base_orig");
  802:   $safeinit .= ';$external::target="'.$target.'";';
  803:   my $rndseed;
  804:   my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
  805:   $rndseed=&Apache::lonnet::rndseed($symb,$courseid,$domain,$name);
  806:   $safeinit .= ';$external::randomseed='.$rndseed.';';
  807:   &Apache::lonxml::debug("Setting rndseed to $rndseed");
  808:   &Apache::run::run($safeinit,$safeeval);
  809: }
  810: 
  811: sub default_homework_load {
  812:     my ($safeeval)=@_;
  813:     &Apache::lonxml::debug('Loading default_homework');
  814:     my $default=&Apache::lonnet::getfile('/home/httpd/html/res/adm/includes/default_homework.lcpm');
  815:     if ($default eq -1) {
  816: 	&Apache::lonxml::error("<b>Unable to find <i>default_homework.lcpm</i></b>");
  817:     } else {
  818: 	&Apache::run::run($default,$safeeval);
  819: 	$Apache::lonxml::default_homework_loaded=1;
  820:     }
  821: }
  822: 
  823: sub startredirection {
  824:   $Apache::lonxml::redirection++;
  825:   push (@Apache::lonxml::outputstack, '');
  826: }
  827: 
  828: sub endredirection {
  829:   if (!$Apache::lonxml::redirection) {
  830:     &Apache::lonxml::error("Endredirection was called, before a startredirection, perhaps you have unbalanced tags. Some debuging information:".join ":",caller);
  831:     return '';
  832:   }
  833:   $Apache::lonxml::redirection--;
  834:   pop @Apache::lonxml::outputstack;
  835: }
  836: 
  837: sub end_tag {
  838:   my ($tagstack,$parstack,$token)=@_;
  839:   pop(@$tagstack);
  840:   pop(@$parstack);
  841:   &decreasedepth($token);
  842: }
  843: 
  844: sub initdepth {
  845:   @Apache::lonxml::depthcounter=();
  846:   $Apache::lonxml::depth=-1;
  847:   $Apache::lonxml::olddepth=-1;
  848: }
  849: 
  850: sub increasedepth {
  851:   my ($token) = @_;
  852:   $Apache::lonxml::depth++;
  853:   $Apache::lonxml::depthcounter[$Apache::lonxml::depth]++;
  854:   if ($Apache::lonxml::depthcounter[$Apache::lonxml::depth]==1) {
  855:     $Apache::lonxml::olddepth=$Apache::lonxml::depth;
  856:   }
  857:   my $curdepth=join('_',@Apache::lonxml::depthcounter);
  858:   &Apache::lonxml::debug("s $Apache::lonxml::depth : $Apache::lonxml::olddepth : $curdepth : $token->[1]\n");
  859: #print "<br />s $Apache::lonxml::depth : $Apache::lonxml::olddepth : $curdepth : $token->[1]\n";
  860: }
  861: 
  862: sub decreasedepth {
  863:   my ($token) = @_;
  864:   $Apache::lonxml::depth--;
  865:   if ($Apache::lonxml::depth<$Apache::lonxml::olddepth-1) {
  866:     $#Apache::lonxml::depthcounter--;
  867:     $Apache::lonxml::olddepth=$Apache::lonxml::depth+1;
  868:   }
  869:   if (  $Apache::lonxml::depth < -1) {
  870:     &Apache::lonxml::warning("Missing tags, unable to properly run file.");
  871:     $Apache::lonxml::depth='-1';
  872:   }
  873:   my $curdepth=join('_',@Apache::lonxml::depthcounter);
  874:   &Apache::lonxml::debug("e $Apache::lonxml::depth : $Apache::lonxml::olddepth : $token->[1] : $curdepth\n");
  875: #print "<br />e $Apache::lonxml::depth : $Apache::lonxml::olddepth : $token->[1] : $curdepth\n";
  876: }
  877: 
  878: sub get_all_text_unbalanced {
  879: #there is a copy of this in lonpublisher.pm
  880:  my($tag,$pars)= @_;
  881:  my $token;
  882:  my $result='';
  883:  $tag='<'.$tag.'>';
  884:  while ($token = $$pars[-1]->get_token) {
  885:    if (($token->[0] eq 'T')||($token->[0] eq 'C')||($token->[0] eq 'D')) {
  886:      $result.=$token->[1];
  887:    } elsif ($token->[0] eq 'PI') {
  888:      $result.=$token->[2];
  889:    } elsif ($token->[0] eq 'S') {
  890:      $result.=$token->[4];
  891:    } elsif ($token->[0] eq 'E')  {
  892:      $result.=$token->[2];
  893:    }
  894:    if ($result =~ /(.*)\Q$tag\E(.*)/s) {
  895:      &Apache::lonxml::debug('Got a winner with leftovers ::'.$2);
  896:      &Apache::lonxml::debug('Result is :'.$1);
  897:      $result=$1;
  898:      my $redo=$tag.$2;
  899:      &Apache::lonxml::newparser($pars,\$redo);
  900:      last;
  901:    }
  902:  }
  903:  return $result
  904: }
  905: 
  906: sub increment_counter {
  907:     my ($increment) = @_;
  908:     if (defined($increment) && $increment gt 0) {
  909: 	$Apache::lonxml::counter+=$increment;
  910:     } else {
  911: 	$Apache::lonxml::counter++;
  912:     }
  913:     $Apache::lonxml::counter_changed=1;
  914: }
  915: 
  916: sub init_counter {
  917:     if (defined($ENV{'form.counter'})) {
  918: 	$Apache::lonxml::counter=$ENV{'form.counter'};
  919: 	$Apache::lonxml::counter_changed=0;
  920:     } else {
  921: 	$Apache::lonxml::counter=1;
  922: 	$Apache::lonxml::counter_changed=1;
  923:     }
  924: }
  925: 
  926: sub store_counter {
  927:     &Apache::lonnet::appenv(('form.counter' => $Apache::lonxml::counter));
  928:     return '';
  929: }
  930: 
  931: sub get_all_text {
  932:  my($tag,$pars)= @_;
  933:  &Apache::lonxml::debug("Got a ".ref($pars));
  934:  my $gotfullstack=1;
  935:  if (ref($pars) ne 'ARRAY') {
  936:      $gotfullstack=0;
  937:      $pars=[$pars];
  938:  }
  939:  my $depth=0;
  940:  my $token;
  941:  my $result='';
  942:  if ( $tag =~ m:^/: ) { 
  943:    my $tag=substr($tag,1); 
  944:    #&Apache::lonxml::debug("have:$tag:");
  945:    my $top_empty=0;
  946:    while (($depth >=0) && ($#$pars > -1) && (!$top_empty)) {
  947:      while (($depth >=0) && ($token = $$pars[-1]->get_token)) {
  948:        #&Apache::lonxml::debug("e token:$token->[0]:$depth:$token->[1]:".$#$pars.":".$#Apache::lonxml::pwd);
  949:        if (($token->[0] eq 'T')||($token->[0] eq 'C')||($token->[0] eq 'D')) {
  950: 	 $result.=$token->[1];
  951:        } elsif ($token->[0] eq 'PI') {
  952: 	 $result.=$token->[2];
  953:        } elsif ($token->[0] eq 'S') {
  954: 	 if ($token->[1] =~ /^$tag$/i) { $depth++; }
  955: 	 $result.=$token->[4];
  956:        } elsif ($token->[0] eq 'E')  {
  957: 	 if ( $token->[1] =~ /^$tag$/i) { $depth--; }
  958: 	 #skip sending back the last end tag
  959: 	 if ($depth > -1) { $result.=$token->[2]; } else {
  960: 	   $$pars[-1]->unget_token($token);
  961: 	 }
  962:        }
  963:      }
  964:      if (($depth >=0) && ($#$pars == 0) ) { $top_empty=1; }
  965:      if (($depth >=0) && ($#$pars > 0) ) {
  966:        pop(@$pars);
  967:        pop(@Apache::lonxml::pwd);
  968:      }
  969:    }
  970:    if ($top_empty && $depth >= 0) {
  971:        #never found the end tag ran out of text, throw error send back blank
  972:        &error('Never found end tag for &lt;'.$tag.'&gt;');
  973:        if ($gotfullstack) {
  974: 	   my $newstring='</'.$tag.'>'.$result;
  975: 	   &Apache::lonxml::newparser($pars,\$newstring);
  976:        }
  977:        $result='';
  978:    }
  979:  } else {
  980:      while ($#$pars > -1) {
  981: 	 while ($token = $$pars[-1]->get_token) {
  982: 	     #&Apache::lonxml::debug("s token:$token->[0]:$depth:$token->[1]");
  983: 	     if (($token->[0] eq 'T')||($token->[0] eq 'C')||
  984: 		 ($token->[0] eq 'D')) {
  985: 		 $result.=$token->[1];
  986: 	     } elsif ($token->[0] eq 'PI') {
  987: 		 $result.=$token->[2];
  988: 	     } elsif ($token->[0] eq 'S') {
  989: 		 if ( $token->[1] =~ /^$tag$/i) {
  990: 		     $$pars[-1]->unget_token($token); last;
  991: 		 } else {
  992: 		     $result.=$token->[4];
  993: 		 }
  994: 	     } elsif ($token->[0] eq 'E')  {
  995: 		 $result.=$token->[2];
  996: 	     }
  997: 	 }
  998: 	 if (($#$pars > 0) ) {
  999: 	     pop(@$pars);
 1000: 	     pop(@Apache::lonxml::pwd);
 1001: 	 } else { last; }
 1002:      }
 1003:  }
 1004:  if ($result =~ m|<LONCAPA_INTERNAL_TURN_STYLE_ON />|) {
 1005:      $Apache::lonxml::usestyle=1;
 1006:  }
 1007:  #&Apache::lonxml::debug("Exit:$result:");
 1008:  return $result
 1009: }
 1010: 
 1011: sub newparser {
 1012:   my ($parser,$contentref,$dir) = @_;
 1013:   push (@$parser,HTML::LCParser->new($contentref));
 1014:   $$parser['-1']->xml_mode('1');
 1015:   if ( $dir eq '' ) {
 1016:     push (@Apache::lonxml::pwd, $Apache::lonxml::pwd[$#Apache::lonxml::pwd]);
 1017:   } else {
 1018:     push (@Apache::lonxml::pwd, $dir);
 1019:   } 
 1020: #  &Apache::lonxml::debug("pwd:$#Apache::lonxml::pwd");
 1021: #  &Apache::lonxml::debug("pwd:$Apache::lonxml::pwd[$#Apache::lonxml::pwd]");
 1022: }
 1023: 
 1024: sub parstring {
 1025:   my ($token) = @_;
 1026:   my $temp='';
 1027:   foreach (@{$token->[3]}) {
 1028:     unless ($_=~/\W/) {
 1029:       my $val=$token->[2]->{$_};
 1030:       $val =~ s/([\%\@\\\"\'])/\\$1/g;
 1031:       #if ($val =~ m/^[\%\@]/) { $val="\\".$val; }
 1032:       $temp .= "my \$$_=\"$val\";"
 1033:     }
 1034:   }
 1035:   return $temp;
 1036: }
 1037: 
 1038: sub writeallows {
 1039:     unless ($#extlinks>=0) { return; }
 1040:     my $thisurl='/res/'.&Apache::lonnet::declutter(shift);
 1041:     if ($ENV{'httpref.'.$thisurl}) {
 1042: 	$thisurl=$ENV{'httpref.'.$thisurl};
 1043:     }
 1044:     my $thisdir=$thisurl;
 1045:     $thisdir=~s/\/[^\/]+$//;
 1046:     my %httpref=();
 1047:     foreach (@extlinks) {
 1048:        $httpref{'httpref.'.
 1049:  	        &Apache::lonnet::hreflocation($thisdir,$_)}=$thisurl;
 1050:     }
 1051:     @extlinks=();
 1052:     &Apache::lonnet::appenv(%httpref);
 1053: }
 1054: 
 1055: #
 1056: # Afterburner handles anchors, highlights and links
 1057: #
 1058: sub afterburn {
 1059:     my $result=shift;
 1060:     &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},
 1061: 					    ['highlight','anchor','link']);
 1062:     if ($ENV{'form.highlight'}) {
 1063:        foreach (split(/\,/,$ENV{'form.highlight'})) {
 1064:            my $anchorname=$_;
 1065: 	   my $matchthis=$anchorname;
 1066:            $matchthis=~s/\_+/\\s\+/g;
 1067:            $result=~s/($matchthis)/\<font color=\"red\"\>$1\<\/font\>/gs;
 1068:        }
 1069:     }
 1070:     if ($ENV{'form.link'}) {
 1071:        foreach (split(/\,/,$ENV{'form.link'})) {
 1072:            my ($anchorname,$linkurl)=split(/\>/,$_);
 1073: 	   my $matchthis=$anchorname;
 1074:            $matchthis=~s/\_+/\\s\+/g;
 1075:            $result=~s/($matchthis)/\<a href=\"$linkurl\"\>$1\<\/a\>/gs;
 1076:        }
 1077:     }
 1078:     if ($ENV{'form.anchor'}) {
 1079:         my $anchorname=$ENV{'form.anchor'};
 1080: 	my $matchthis=$anchorname;
 1081:         $matchthis=~s/\_+/\\s\+/g;
 1082:         $result=~s/($matchthis)/\<a name=\"$anchorname\"\>$1\<\/a\>/s;
 1083:         $result.=(<<"ENDSCRIPT");
 1084: <script type="text/javascript">
 1085:     document.location.hash='$anchorname';
 1086: </script>
 1087: ENDSCRIPT
 1088:     }
 1089:     return $result;
 1090: }
 1091: 
 1092: sub storefile {
 1093:     my ($file,$contents)=@_;
 1094:     if (my $fh=Apache::File->new('>'.$file)) {
 1095: 	print $fh $contents;
 1096:         $fh->close();
 1097:     } else {
 1098:       &warning("Unable to save file $file");
 1099:     }
 1100: }
 1101: 
 1102: sub createnewhtml {
 1103:   my $filecontents=(<<SIMPLECONTENT);
 1104: <html>
 1105: <head>
 1106: <title>
 1107:                            Title of Document Goes Here
 1108: </title>
 1109: </head>
 1110: <body bgcolor="#FFFFFF">
 1111: 
 1112:                            Body of Document Goes Here
 1113: 
 1114: </body>
 1115: </html>
 1116: SIMPLECONTENT
 1117:   return $filecontents;
 1118: }
 1119: 
 1120: 
 1121: sub inserteditinfo {
 1122:       my ($result,$filecontents)=@_;
 1123:       $filecontents = &HTML::Entities::encode($filecontents);
 1124: #      my $editheader='<a href="#editsection">Edit below</a><hr />';
 1125:       my $xml_help = '<table><tr><td>'.
 1126: 	  &Apache::loncommon::help_open_topic("Greek_Symbols",'Greek Symbols',
 1127: 					      undef,undef,600)
 1128: 	      .'</td><td>'.
 1129:           &Apache::loncommon::help_open_topic("Other_Symbols",'Other Symbols',
 1130: 					      undef,undef,600)
 1131: 	      .'</td></tr></table>';
 1132:       my $buttons=(<<BUTTONS);
 1133: <input type="submit" name="attemptclean" 
 1134:        value="Save and then attempt to clean HTML" />
 1135: <input type="submit" name="savethisfile" value="Save this" />
 1136: <input type="submit" name="viewmode" value="View" />
 1137: BUTTONS
 1138:       my $editfooter=(<<ENDFOOTER);
 1139: <hr />
 1140: <a name="editsection" />
 1141: <form method="post">
 1142: $xml_help
 1143: <input type="hidden" name="editmode" value="Edit" />
 1144: $buttons<br />
 1145: <textarea cols="80" rows="40" name="filecont">$filecontents</textarea>
 1146: <br />$buttons
 1147: <br />
 1148: </form>
 1149: ENDFOOTER
 1150: #      $result=~s/(\<body[^\>]*\>)/$1$editheader/is;
 1151:       $result=~s/(\<\/body\>)/$editfooter/is;
 1152:       return $result;
 1153: }
 1154: 
 1155: sub get_target {
 1156:   my $viewgrades=&Apache::lonnet::allowed('vgr',$ENV{'request.course.id'});
 1157:   if ( $ENV{'request.state'} eq 'published') {
 1158:     if ( defined($ENV{'form.grade_target'})
 1159: 	 && ($viewgrades == 'F' )) {
 1160:       return ($ENV{'form.grade_target'});
 1161:     } elsif (defined($ENV{'form.grade_target'})) {
 1162:       if (($ENV{'form.grade_target'} eq 'web') ||
 1163: 	  ($ENV{'form.grade_target'} eq 'tex') ) {
 1164: 	return $ENV{'form.grade_target'}
 1165:       } else {
 1166: 	return 'web';
 1167:       }
 1168:     } else {
 1169:       return 'web';
 1170:     }
 1171:   } elsif ($ENV{'request.state'} eq 'construct') {
 1172:     if ( defined($ENV{'form.grade_target'})) {
 1173:       return ($ENV{'form.grade_target'});
 1174:     } else {
 1175:       return 'web';
 1176:     }
 1177:   } else {
 1178:     return 'web';
 1179:   }
 1180: }
 1181: 
 1182: sub handler {
 1183:   my $request=shift;
 1184: 
 1185:   my $target=&get_target();
 1186: 
 1187:   $Apache::lonxml::debug=0;
 1188: 
 1189:   if ($ENV{'browser.mathml'}) {
 1190:     $request->content_type('text/xml');
 1191:   } else {
 1192:     $request->content_type('text/html');
 1193:   }
 1194:   &Apache::loncommon::no_cache($request);
 1195:   $request->send_http_header;
 1196: 
 1197:   return OK if $request->header_only;
 1198: 
 1199: 
 1200:   my $file=&Apache::lonnet::filelocation("",$request->uri);
 1201: #
 1202: # Edit action? Save file.
 1203: #
 1204:   unless ($ENV{'request.state'} eq 'published') {
 1205:       if (($ENV{'form.savethisfile'}) || ($ENV{'form.attemptclean'})) {
 1206: 	  &storefile($file,$ENV{'form.filecont'});
 1207:       }
 1208:   }
 1209:   my %mystyle;
 1210:   my $result = '';
 1211:   my $filecontents=&Apache::lonnet::getfile($file);
 1212:   if ($filecontents eq -1) {
 1213:     $result=(<<ENDNOTFOUND);
 1214: <html>
 1215: <head>
 1216: <title>File not found</title>
 1217: </head>
 1218: <body bgcolor="#FFFFFF">
 1219: <b>File not found: $file</b>
 1220: </body>
 1221: </html>
 1222: ENDNOTFOUND
 1223:     $filecontents='';
 1224:     if ($ENV{'request.state'} ne 'published') {
 1225:       $filecontents=&createnewhtml();
 1226:       $ENV{'form.editmode'}='Edit'; #force edit mode
 1227:     }
 1228:   } else {
 1229:     unless ($ENV{'request.state'} eq 'published') {
 1230:       if ($ENV{'form.attemptclean'}) {
 1231: 	$filecontents=&htmlclean($filecontents,1);
 1232:       }
 1233:     }
 1234:     if (!$ENV{'form.editmode'} || $ENV{'form.viewmode'}) {
 1235:       $result = &Apache::lonxml::xmlparse($request,$target,$filecontents,
 1236: 					  '',%mystyle);
 1237:     }
 1238:   }
 1239: 
 1240: #
 1241: # Edit action? Insert editing commands
 1242: #
 1243:   unless ($ENV{'request.state'} eq 'published') {
 1244:     if ($ENV{'form.editmode'} && (!($ENV{'form.viewmode'}))) {
 1245: 	my $displayfile=$request->uri;
 1246:         $displayfile=~s/^\/[^\/]*//;
 1247:       $result='<html><body bgcolor="#FFFFFF"><h3>'.$displayfile.
 1248:               '</h3></body></html>';
 1249:       $result=&inserteditinfo($result,$filecontents);
 1250:     }
 1251:   }
 1252: 
 1253:   writeallows($request->uri);
 1254: 
 1255:   # If we're editing, show the filename of the resource in the frame's main
 1256:   # title
 1257:   if ($ENV{'form.editmode'}) {
 1258:       my $filename = $request->uri;
 1259:       # Everything after the last /
 1260:       $filename = substr($filename, rindex($filename, '/') + 1);
 1261:       $result = substr($result, 0, rindex($result, '</html>'));
 1262:       $result .= "<script>top.document.title = '$filename - LON-CAPA Construction Space';</script>";
 1263:       $result .= "\n</html>\n";
 1264:   }
 1265: 
 1266: 
 1267:   $request->print($result);
 1268: 
 1269:   return OK;
 1270: }
 1271: 
 1272: sub debug {
 1273:   if ($Apache::lonxml::debug eq 1) {
 1274:     $|=1;
 1275:     print('<font size="-2"<pre>DEBUG:'.&HTML::Entities::encode($_[0])."</pre></font>\n");
 1276:   }
 1277: }
 1278: 
 1279: sub error {
 1280:   $errorcount++;
 1281:   if (($Apache::lonxml::debug eq 1) || ($ENV{'request.state'} eq 'construct') ) {
 1282:     # If printing in construction space, put the error inside <pre></pre>
 1283:     print "<b>ERROR:</b>".join("\n",@_)."\n";
 1284:   } else {
 1285:     print "<b>An Error occured while processing this resource. The instructor has been notified.</b> <br />";
 1286:     #notify author
 1287:     &Apache::lonmsg::author_res_msg($ENV{'request.filename'},join('<br />',@_));
 1288:     #notify course
 1289:     if ( $ENV{'request.course.id'} ) {
 1290:       my (undef,%users)=&Apache::lonfeedback::decide_receiver(undef,0,1,1,1);
 1291:       my $declutter=&Apache::lonnet::declutter($ENV{'request.filename'});
 1292:       foreach (keys %users) {
 1293: 	my ($user,$domain) = split(/:/, $_);
 1294: 	&Apache::lonmsg::user_normal_msg($user,$domain,
 1295:         "Error [$declutter]",join('<br />',@_));
 1296:       }
 1297:     }
 1298: 
 1299:     #FIXME probably shouldn't have me get everything forever.
 1300:     &Apache::lonmsg::user_normal_msg('albertel','msu',"Error in $ENV{'request.filename'}",join('<br />',@_));
 1301:     #&Apache::lonmsg::user_normal_msg('albertel','103',"Error in $ENV{'request.filename'}",$_[0]);
 1302:   }
 1303: }
 1304: 
 1305: sub warning {
 1306:   $warningcount++;
 1307:   if ($ENV{'request.state'} eq 'construct') {
 1308:     print "<b>W</b>ARNING<b>:</b>".join('<br />',@_)."<br />\n";
 1309:   }
 1310: }
 1311: 
 1312: sub get_param {
 1313:     my ($param,$parstack,$safeeval,$context,$case_insensitive) = @_;
 1314:     if ( ! $context ) { $context = -1; }
 1315:     my $args ='';
 1316:     if ( $#$parstack > (-2-$context) ) { $args=$$parstack[$context]; }
 1317:     if ( ! $args ) { return undef; }
 1318:     if ( $case_insensitive ) {
 1319: 	if ($args =~ s/(my \$)(\Q$param\E)(=\")/$1.lc($2).$3/ei) {
 1320: 	    return &Apache::run::run("{$args;".'return $'.$param.'}',
 1321:                                      $safeeval); #'
 1322: 	} else {
 1323: 	    return undef;
 1324: 	}
 1325:     } else {
 1326: 	if ( $args =~ /my \$\Q$param\E=\"/ ) {
 1327: 	    return &Apache::run::run("{$args;".'return $'.$param.'}',
 1328:                                      $safeeval); #'
 1329: 	} else {
 1330: 	    return undef;
 1331: 	}
 1332:     }
 1333: }
 1334: 
 1335: sub get_param_var {
 1336:   my ($param,$parstack,$safeeval,$context,$case_insensitive) = @_;
 1337:   if ( ! $context ) { $context = -1; }
 1338:   my $args ='';
 1339:   if ( $#$parstack > (-2-$context) ) { $args=$$parstack[$context]; }
 1340:   &Apache::lonxml::debug("Args are $args param is $param");
 1341:   if ($case_insensitive) {
 1342:       if (! ($args=~s/(my \$)(\Q$param\E)(=\")/$1.lc($2).$3/ei)) {
 1343: 	  return undef;
 1344:       }
 1345:   } elsif ( $args !~ /my \$\Q$param\E=\"/ ) { return undef; }
 1346:   my $value=&Apache::run::run("{$args;".'return $'.$param.'}',$safeeval); #'
 1347:   &Apache::lonxml::debug("first run is $value");
 1348:   if ($value =~ /^[\$\@\%]\w+$/) {
 1349:       &Apache::lonxml::debug("doing second");
 1350:       my @result=&Apache::run::run("return $value",$safeeval,1);
 1351:       if (!defined($result[0])) {
 1352: 	  return $value
 1353:       } else {
 1354: 	  if (wantarray) { return @result; } else { return $result[0]; }
 1355:       }
 1356:   } else {
 1357:     return $value;
 1358:   }
 1359: }
 1360: 
 1361: sub register_insert {
 1362:   my @data = split /\n/, &Apache::lonnet::getfile('/home/httpd/lonTabs/insertlist.tab');
 1363:   my $i;
 1364:   my $tagnum=0;
 1365:   my @order;
 1366:   for ($i=0;$i < $#data; $i++) {
 1367:     my $line = $data[$i];
 1368:     if ( $line =~ /^\#/ || $line =~ /^\s*\n/) { next; }
 1369:     if ( $line =~ /TABLE/ ) { last; }
 1370:     my ($tag,$descrip,$color,$function,$show) = split(/,/, $line);
 1371:     if ($tag) {
 1372:       $insertlist{"$tagnum.tag"} = $tag;
 1373:       $insertlist{"$tagnum.description"} = $descrip;
 1374:       $insertlist{"$tagnum.color"} = $color;
 1375:       $insertlist{"$tagnum.function"} = $function;
 1376:       if (!defined($show)) { $show='yes'; }
 1377:       $insertlist{"$tagnum.show"}= $show;
 1378:       $insertlist{"$tag.num"}=$tagnum;
 1379:       $tagnum++;
 1380:     }
 1381:   }
 1382:   $i++; #skipping TABLE line
 1383:   $tagnum = 0;
 1384:   for (;$i < $#data;$i++) {
 1385:     my $line = $data[$i];
 1386:     my ($mnemonic,@which) = split(/ +/,$line);
 1387:     my $tag = $insertlist{"$tagnum.tag"};
 1388:     for (my $j=0;$j <=$#which;$j++) {
 1389:       if ( $which[$j] eq 'Y' ) {
 1390: 	if ($insertlist{"$j.show"} ne 'no') {
 1391: 	  push(@{ $insertlist{"$tag.which"} },$j);
 1392: 	}
 1393:       }
 1394:     }
 1395:     $tagnum++;
 1396:   }
 1397: }
 1398: 
 1399: sub description {
 1400:   my ($token)=@_;
 1401:   my $tagnum;
 1402:   my $tag=$token->[1];
 1403:   foreach my $namespace (reverse @Apache::lonxml::namespace) {
 1404:     my $testtag=$namespace.'::'.$tag;
 1405:     $tagnum=$insertlist{"$testtag.num"};
 1406:     if (defined($tagnum)) { last; }
 1407:   }
 1408:   if (!defined ($tagnum)) { $tagnum=$Apache::lonxml::insertlist{"$tag.num"}; }
 1409:   return $insertlist{$tagnum.'.description'};
 1410: }
 1411: 
 1412: # ----------------------------------------------------------------- whichuser
 1413: # returns a list of $symb, $courseid, $domain, $name that is correct for
 1414: # calls to lonnet functions for this setup.
 1415: # - looks for form.grade_ parameters
 1416: sub whichuser {
 1417:   my ($symb,$courseid,$domain,$name,$publicuser);
 1418:   if (defined($ENV{'form.grade_symb'})) {
 1419:     my $tmp_courseid=$ENV{'form.grade_courseid'};
 1420:     my $allowed=&Apache::lonnet::allowed('mgr',$tmp_courseid);
 1421:     if ($allowed) {
 1422:       $symb=$ENV{'form.grade_symb'};
 1423:       $courseid=$ENV{'form.grade_courseid'};
 1424:       $domain=$ENV{'form.grade_domain'};
 1425:       $name=$ENV{'form.grade_username'};
 1426:     }
 1427:   } else {
 1428:       $symb=&Apache::lonnet::symbread();
 1429:       $courseid=$ENV{'request.course.id'};
 1430:       $domain=$ENV{'user.domain'};
 1431:       $name=$ENV{'user.name'};
 1432:       if ($name eq 'public' && $domain eq 'public') {
 1433: 	  if (!defined($ENV{'form.username'})) {
 1434: 	      $ENV{'form.username'}.=time.rand(10000000);
 1435: 	  }
 1436: 	  $name.=$ENV{'form.username'};
 1437:       }
 1438:   }
 1439:   return ($symb,$courseid,$domain,$name,$publicuser);
 1440: }
 1441: 
 1442: 1;
 1443: __END__
 1444: 
 1445: 

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