File:  [LON-CAPA] / loncom / xml / lonxml.pm
Revision 1.357: download - view: text, annotated - select for diffs
Sat Feb 26 05:37:23 2005 UTC (19 years, 4 months ago) by albertel
Branches: MAIN
CVS tags: HEAD
- ttm can now be forced on, which means Hi XML, what you mean we really have to be xml now?
   - roles screen with no roles doesn't barf in xml mode
   - viewing a homework problem with an inline remote and no selected roles doesn't baf
   - pref screen to change back to something else doesn't barf

- no guarentees about anything else, not that the remote control in particular is non functional

    1: # The LearningOnline Network with CAPA
    2: # XML Parser Module 
    3: #
    4: # $Id: lonxml.pm,v 1.357 2005/02/26 05:37:23 albertel 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: 
   40: 
   41: package Apache::lonxml; 
   42: use vars 
   43: qw(@pwd @outputstack $redirection $import @extlinks $metamode $evaluate %insertlist @namespace $errorcount $warningcount @htmlareafields);
   44: use strict;
   45: use HTML::LCParser();
   46: use HTML::TreeBuilder();
   47: use HTML::Entities();
   48: use Safe();
   49: use Safe::Hole();
   50: use Math::Cephes();
   51: use Math::Random();
   52: use Opcode();
   53: use POSIX qw(strftime);
   54: use Time::HiRes qw( gettimeofday tv_interval );
   55: 
   56: sub register {
   57:   my ($space,@taglist) = @_;
   58:   foreach my $temptag (@taglist) {
   59:     push(@{ $Apache::lonxml::alltags{$temptag} },$space);
   60:   }
   61: }
   62: 
   63: sub deregister {
   64:   my ($space,@taglist) = @_;
   65:   foreach my $temptag (@taglist) {
   66:     my $tempspace = $Apache::lonxml::alltags{$temptag}[-1];
   67:     if ($tempspace eq $space) {
   68:       pop(@{ $Apache::lonxml::alltags{$temptag} });
   69:     }
   70:   }
   71:   #&printalltags();
   72: }
   73: 
   74: use Apache::Constants qw(:common);
   75: use Apache::lontexconvert();
   76: use Apache::style();
   77: use Apache::run();
   78: use Apache::londefdef();
   79: use Apache::scripttag();
   80: use Apache::languagetags();
   81: use Apache::edit();
   82: use Apache::inputtags();
   83: use Apache::outputtags();
   84: use Apache::lonnet();
   85: use Apache::File();
   86: use Apache::loncommon();
   87: use Apache::lonfeedback();
   88: use Apache::lonmsg();
   89: use Apache::loncacc();
   90: use Apache::lonlocal;
   91: 
   92: #==================================================   Main subroutine: xmlparse  
   93: #debugging control, to turn on debugging modify the correct handler
   94: $Apache::lonxml::debug=0;
   95: 
   96: # keeps count of the number of warnings and errors generated in a parse
   97: $warningcount=0;
   98: $errorcount=0;
   99: 
  100: #path to the directory containing the file currently being processed
  101: @pwd=();
  102: 
  103: #these two are used for capturing a subset of the output for later processing,
  104: #don't touch them directly use &startredirection and &endredirection
  105: @outputstack = ();
  106: $redirection = 0;
  107: 
  108: #controls wheter the <import> tag actually does
  109: $import = 1;
  110: @extlinks=();
  111: 
  112: # meta mode is a bit weird only some output is to be turned off
  113: #<output> tag turns metamode off (defined in londefdef.pm)
  114: $metamode = 0;
  115: 
  116: # turns on and of run::evaluate actually derefencing var refs
  117: $evaluate = 1;
  118: 
  119: # data structure for eidt mode, determines what tags can go into what other tags
  120: %insertlist=();
  121: 
  122: # stores the list of active tag namespaces
  123: @namespace=();
  124: 
  125: # has the dynamic menu been updated to know about this resource
  126: $Apache::lonxml::registered=0;
  127: 
  128: # a pointer the the Apache request object
  129: $Apache::lonxml::request='';
  130: 
  131: # a problem number counter, and check on ether it is used
  132: $Apache::lonxml::counter=1;
  133: $Apache::lonxml::counter_changed=0;
  134: 
  135: #internal check on whether to look at style defs
  136: $Apache::lonxml::usestyle=1;
  137: 
  138: #locations used to store the parameter string for style substitutions
  139: $Apache::lonxml::style_values='';
  140: $Apache::lonxml::style_end_values='';
  141: 
  142: #array of ssi calls that need to occur after we are done parsing
  143: @Apache::lonxml::ssi_info=();
  144: 
  145: #should we do the postag variable interpolation
  146: $Apache::lonxml::post_evaluate=1;
  147: 
  148: #a header message to emit in the case of any generated warning or errors
  149: $Apache::lonxml::warnings_error_header='';
  150: 
  151: sub xmlbegin {
  152:     my ($style)=@_;
  153:     my $output='';
  154:     @htmlareafields=();
  155:     if ($ENV{'browser.mathml'}) {
  156: 	$output='<?xml version="1.0"?>'
  157:             #.'<?xml-stylesheet type="text/css" href="/adm/MathML/mathml.css"?>'."\n"
  158: #            .'<!DOCTYPE html SYSTEM "/adm/MathML/mathml.dtd" '
  159:             
  160: #	    .'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" [<!ENTITY mathns "http://www.w3.org/1998/Math/MathML">] >'
  161: 	    .'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN" "http://www.w3.org/2002/04/xhtml-math-svg/xhtml-math-svg.dtd">'
  162:             .'<html xmlns:math="http://www.w3.org/1998/Math/MathML" ' 
  163: 	    .'xmlns="http://www.w3.org/1999/xhtml">';
  164:     } else {
  165: 	$output='<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html>';
  166:     }
  167:     if ($style eq 'encode') {
  168: 	$output=&HTML::Entities::encode($output,'<>&"');
  169:     }
  170:     return $output;
  171: }
  172: 
  173: sub xmlend {
  174:     my ($target,$parser)=@_;
  175:     my $mode='xml';
  176:     my $status='OPEN';
  177:     if ($Apache::lonhomework::parsing_a_problem) {
  178: 	$mode='problem';
  179: 	$status=$Apache::inputtags::status[-1]; 
  180:     }
  181:     my $discussion=&Apache::lonfeedback::list_discussion($mode,$status);    
  182:     if ($target eq 'tex') {
  183: 	$discussion.='<tex>\keephidden{ENDOFPROBLEM}\vskip 0.5mm\noindent\makebox[\textwidth/$number_of_columns][b]{\hrulefill}\end{document}</tex>';
  184: 	&Apache::lonxml::newparser($parser,\$discussion,'');
  185: 	return '';
  186:     } else {
  187: 	return $discussion.'</html>';
  188:     }
  189: }
  190: 
  191: sub tokeninputfield {
  192:     my $defhost=$Apache::lonnet::perlvar{'lonHostID'};
  193:     $defhost=~tr/a-z/A-Z/;
  194:     return (<<ENDINPUTFIELD)
  195: <script type="text/javascript">
  196:     function updatetoken() {
  197: 	var comp=new Array;
  198:         var barcode=unescape(document.tokeninput.barcode.value);
  199:         comp=barcode.split('*');
  200:         if (typeof(comp[0])!="undefined") {
  201: 	    document.tokeninput.codeone.value=comp[0];
  202: 	}
  203:         if (typeof(comp[1])!="undefined") {
  204: 	    document.tokeninput.codetwo.value=comp[1];
  205: 	}
  206:         if (typeof(comp[2])!="undefined") {
  207:             comp[2]=comp[2].toUpperCase();
  208: 	    document.tokeninput.codethree.value=comp[2];
  209: 	}
  210:         document.tokeninput.barcode.value='';
  211:     }  
  212: </script>
  213: <form method="post" name="tokeninput">
  214: <table border="2" bgcolor="#FFFFBB">
  215: <tr><th>DocID Checkin</th></tr>
  216: <tr><td>
  217: <table>
  218: <tr>
  219: <td>Scan in Barcode</td>
  220: <td><input type="text" size="22" name="barcode" 
  221: onChange="updatetoken()"/></td>
  222: </tr>
  223: <tr><td><i>or</i> Type in DocID</td>
  224: <td>
  225: <input type="text" size="5" name="codeone" />
  226: <b><font size="+2">*</font></b>
  227: <input type="text" size="5" name="codetwo" />
  228: <b><font size="+2">*</font></b>
  229: <input type="text" size="10" name="codethree" value="$defhost" 
  230: onChange="this.value=this.value.toUpperCase()" />
  231: </td></tr>
  232: </table>
  233: </td></tr>
  234: <tr><td><input type="submit" value="Check in DocID" /></td></tr>
  235: </table>
  236: </form>
  237: ENDINPUTFIELD
  238: }
  239: 
  240: sub maketoken {
  241:     my ($symb,$tuname,$tudom,$tcrsid)=@_;
  242:     unless ($symb) {
  243: 	$symb=&Apache::lonnet::symbread();
  244:     }
  245:     unless ($tuname) {
  246: 	$tuname=$ENV{'user.name'};
  247:         $tudom=$ENV{'user.domain'};
  248:         $tcrsid=$ENV{'request.course.id'};
  249:     }
  250: 
  251:     return &Apache::lonnet::checkout($symb,$tuname,$tudom,$tcrsid);
  252: }
  253: 
  254: sub printtokenheader {
  255:     my ($target,$token,$tsymb,$tcrsid,$tudom,$tuname)=@_;
  256:     unless ($token) { return ''; }
  257: 
  258:     my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
  259:     unless ($tsymb) {
  260: 	$tsymb=$symb;
  261:     }
  262:     unless ($tuname) {
  263: 	$tuname=$name;
  264:         $tudom=$domain;
  265:         $tcrsid=$courseid;
  266:     }
  267: 
  268:     my %reply=&Apache::lonnet::get('environment',
  269:               ['firstname','middlename','lastname','generation'],
  270:               $tudom,$tuname);
  271:     my $plainname=$reply{'firstname'}.' '. 
  272:                   $reply{'middlename'}.' '.
  273:                   $reply{'lastname'}.' '.
  274: 		  $reply{'generation'};
  275: 
  276:     if ($target eq 'web') {
  277:         my %idhash=&Apache::lonnet::idrget($tudom,($tuname));
  278: 	return 
  279:  '<img align="right" src="/cgi-bin/barcode.png?encode='.$token.'" />'.
  280:                &mt('Checked out for').' '.$plainname.
  281:                '<br />'.&mt('User').': '.$tuname.' at '.$tudom.
  282: 	       '<br />'.&mt('ID').': '.$idhash{$tuname}.
  283: 	       '<br />'.&mt('CourseID').': '.$tcrsid.
  284: 	       '<br />'.&mt('Course').': '.$ENV{'course.'.$tcrsid.'.description'}.
  285:                '<br />'.&mt('DocID').': '.$token.
  286:                '<br />'.&mt('Time').': '.&Apache::lonlocal::locallocaltime().'<hr />';
  287:     } else {
  288:         return $token;
  289:     }
  290: }
  291: 
  292: sub fontsettings {
  293:     my $headerstring='';
  294:     if (($ENV{'browser.os'} eq 'mac') && (!$ENV{'browser.mathml'})) { 
  295: 	$headerstring.=
  296: 	    '<meta Content-Type="text/html; charset=x-mac-roman" />';
  297:     } elsif (!$ENV{'browser.mathml'} && $ENV{'browser.unicode'}) {
  298: 	$headerstring.=
  299: 	    '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
  300:     }
  301:     return $headerstring;
  302: }
  303: 
  304: sub printalltags {
  305:   my $temp;
  306:   foreach $temp (sort keys %Apache::lonxml::alltags) {
  307:     &Apache::lonxml::debug("$temp -- ".
  308: 		  join(',',@{ $Apache::lonxml::alltags{$temp} }));
  309:   }
  310: }
  311: 
  312: sub xmlparse {
  313:  my ($request,$target,$content_file_string,$safeinit,%style_for_target) = @_;
  314: 
  315:  &setup_globals($request,$target);
  316:  &Apache::inputtags::initialize_inputtags();
  317:  &Apache::outputtags::initialize_outputtags();
  318:  &Apache::edit::initialize_edit();
  319:  &Apache::londefdef::initialize_londefdef();
  320: 
  321: #
  322: # do we have a course style file?
  323: #
  324: 
  325:  if ($ENV{'request.course.id'} && $ENV{'request.state'} ne 'construct') {
  326:      my $bodytext=
  327: 	 $ENV{'course.'.$ENV{'request.course.id'}.'.default_xml_style'};
  328:      if ($bodytext) {
  329: 	 foreach my $file (split(',',$bodytext)) {
  330: 	     my $location=&Apache::lonnet::filelocation('',$file);
  331: 	     my $styletext=&Apache::lonnet::getfile($location);
  332: 	     if ($styletext ne '-1') {
  333: 		 %style_for_target = (%style_for_target,
  334: 				      &Apache::style::styleparser($target,$styletext));
  335: 	     }
  336: 	 }
  337:      }
  338:  } elsif ($ENV{'construct.style'} && ($ENV{'request.state'} eq 'construct')) {
  339:      my $location=&Apache::lonnet::filelocation('',$ENV{'construct.style'});
  340:      my $styletext=&Apache::lonnet::getfile($location);
  341:        if ($styletext ne '-1') {
  342:           %style_for_target = (%style_for_target,
  343:                           &Apache::style::styleparser($target,$styletext));
  344:       }
  345:  }
  346: #&printalltags();
  347:  my @pars = ();
  348:  my $pwd=$ENV{'request.filename'};
  349:  $pwd =~ s:/[^/]*$::;
  350:  &newparser(\@pars,\$content_file_string,$pwd);
  351: 
  352:  my $safeeval = new Safe;
  353:  my $safehole = new Safe::Hole;
  354:  &init_safespace($target,$safeeval,$safehole,$safeinit);
  355: #-------------------- Redefinition of the target in the case of compound target
  356: 
  357:  ($target, my @tenta) = split('&&',$target);
  358: 
  359:  my @stack = ();
  360:  my @parstack = ();
  361:  &initdepth;
  362: 
  363:  my $finaloutput = &inner_xmlparse($target,\@stack,\@parstack,\@pars,
  364: 				   $safeeval,\%style_for_target);
  365: 
  366:  if ($ENV{'request.uri'}) {
  367:     &writeallows($ENV{'request.uri'});
  368:  }
  369:  &do_registered_ssi();
  370:  if ($Apache::lonxml::counter_changed) { &store_counter() }
  371:  return $finaloutput;
  372: }
  373: 
  374: sub htmlclean {
  375:     my ($raw,$full)=@_;
  376: # Take care of CRLF etc
  377: 
  378:     $raw=~s/\r\f/\n/gs; $raw=~s/\f\r/\n/gs;
  379:     $raw=~s/\r\n/\n/gs; $raw=~s/\n\r/\n/gs;
  380:     $raw=~s/\f/\n/gs; $raw=~s/\r/\n/gs;
  381:     $raw=~s/\&\#10\;/\n/gs; $raw=~s/\&\#13\;/\n/gs;
  382: 
  383: # Generate empty tags, remove wrong end tags
  384:     $raw=~s/\<(br|hr|img|meta|allow|basefont)([^\>\/]*?)\>/\<$1$2 \/\>/gis;
  385:     $raw=~s/\<\/(br|hr|img|meta|allow|basefont)\>//gis;
  386:     unless ($full) {
  387:        $raw=~s/\<[\/]*(body|head|html)\>//gis;
  388:     }
  389: # Make standard tags lowercase
  390:     foreach ('html','body','head','meta','h1','h2','h3','h4','b','i','m',
  391:              'table','tr','td','th','p','br','hr','img','embed','font',
  392:              'a','strong','center','title','basefont','li','ol','ul',
  393:              'input','select','form','option','script','pre') {
  394: 	$raw=~s/\<$_\s*\>/\<$_\>/gis;
  395:         $raw=~s/\<\/$_\s*\>/<\/$_\>/gis;
  396:         $raw=~s/\<$_\s([^\>]*)\>/<$_ $1\>/gis;
  397:     }
  398:     return $raw;
  399: }
  400: 
  401: sub latex_special_symbols {
  402:     my ($string,$where)=@_;
  403:     if ($where eq 'header') {
  404: 	$string =~ s/(\\|_|\^)/ /g;
  405: 	$string =~ s/(\$|%|\{|\})/\\$1/g;
  406: 	$string =~ s/_/ /g;
  407: 	$string=&Apache::lonprintout::character_chart($string);
  408: 	# any & or # leftover should be safe to just escape
  409:         $string=~s/([^\\])\&/$1\\\&/g;
  410:         $string=~s/([^\\])\#/$1\\\#/g;
  411:     } else {
  412: 	$string=~s/\\/\\ensuremath{\\backslash}/g;
  413: 	$string=~s/([^\\]|^)\%/$1\\\%/g;
  414: 	$string=~s/([^\\]|^)\$/$1\\\$/g;
  415: 	$string=~s/([^\\])\_/$1\\_/g;
  416: 	$string=~s/\$\$/\$\\\$/g;
  417: 	$string=~s/\_\_/\_\\\_/g;
  418: 	$string=~s/\#\#/\#\\\#/g;
  419:         $string=~s/([^\\]|^)(\~|\^)/$1\\$2\\strut /g;
  420: 	$string=~s/(>|<)/\\ensuremath\{$1\}/g; #more or less
  421: 	$string=&Apache::lonprintout::character_chart($string);
  422: 	# any & or # leftover should be safe to just escape
  423:         $string=~s/([^\\]|^)\&/$1\\\&/g;
  424:         $string=~s/([^\\]|^)\#/$1\\\#/g;
  425:         $string=~s/\|/\$\\mid\$/g;
  426: #single { or } How to escape?
  427:     }
  428:     return $string;
  429: }
  430: 
  431: sub inner_xmlparse {
  432:   my ($target,$stack,$parstack,$pars,$safeeval,$style_for_target)=@_;
  433:   my $finaloutput = '';
  434:   my $result;
  435:   my $token;
  436:   my $dontpop=0;
  437:   while ( $#$pars > -1 ) {
  438:     while ($token = $$pars['-1']->get_token) {
  439:       if (($token->[0] eq 'T') || ($token->[0] eq 'C') ) {
  440: 	if ($metamode<1) {
  441: 	    my $text=$token->[1];
  442: 	    if ($token->[0] eq 'C' && $target eq 'tex') {
  443: 		$text = '';
  444: #		$text = '%'.$text."\n";
  445: 	    }
  446: 	    $result.=$text;
  447: 	}
  448:       } elsif (($token->[0] eq 'D')) {
  449: 	if ($metamode<1 && $target eq 'web') {
  450: 	    my $text=$token->[1];
  451: 	    $result.=$text;
  452: 	}
  453:       } elsif ($token->[0] eq 'PI') {
  454: 	if ($metamode<1 && $target eq 'web') {
  455: 	  $result=$token->[2];
  456: 	}
  457:       } elsif ($token->[0] eq 'S') {
  458: 	# add tag to stack
  459: 	push (@$stack,$token->[1]);
  460: 	# add parameters list to another stack
  461: 	push (@$parstack,&parstring($token));
  462: 	&increasedepth($token);
  463: 	if ($Apache::lonxml::usestyle &&
  464: 	    exists($$style_for_target{$token->[1]})) {
  465: 	    $Apache::lonxml::usestyle=0;
  466: 	    my $string=$$style_for_target{$token->[1]}.
  467: 	      '<LONCAPA_INTERNAL_TURN_STYLE_ON />';
  468: 	    &Apache::lonxml::newparser($pars,\$string);
  469: 	    $Apache::lonxml::style_values=$$parstack[-1];
  470: 	    $Apache::lonxml::style_end_values=$$parstack[-1];
  471: 	} else {
  472: 	  $result = &callsub("start_$token->[1]", $target, $token, $stack,
  473: 			     $parstack, $pars, $safeeval, $style_for_target);
  474: 	}
  475:       } elsif ($token->[0] eq 'E') {
  476: 	if ($Apache::lonxml::usestyle &&
  477: 	    exists($$style_for_target{'/'."$token->[1]"})) {
  478: 	    $Apache::lonxml::usestyle=0;
  479: 	    my $string=$$style_for_target{'/'.$token->[1]}.
  480: 	      '<LONCAPA_INTERNAL_TURN_STYLE_ON end="'.$token->[1].'" />';
  481: 	    &Apache::lonxml::newparser($pars,\$string);
  482: 	    $Apache::lonxml::style_values=$Apache::lonxml::style_end_values;
  483: 	    $Apache::lonxml::style_end_values='';
  484: 	    $dontpop=1;
  485: 	} else {
  486: 	    #clear out any tags that didn't end
  487: 	    while ($token->[1] ne $$stack['-1'] && ($#$stack > -1)) {
  488: 		my $lasttag=$$stack[-1];
  489: 		if ($token->[1] =~ /^\Q$lasttag\E$/i) {
  490: 		    &Apache::lonxml::warning('Using tag &lt;/'.$token->[1].'&gt; on line '.$token->[3].' as end tag to &lt;'.$$stack[-1].'&gt;');
  491: 		    last;
  492: 		} else {
  493: 		    &Apache::lonxml::warning('Found tag &lt;/'.$token->[1].'&gt; on line '.$token->[3].' when looking for &lt;/'.$$stack[-1].'&gt; in file');
  494: 		    &end_tag($stack,$parstack,$token);
  495: 		}
  496: 	    }
  497: 	    $result = &callsub("end_$token->[1]", $target, $token, $stack,
  498: 			       $parstack, $pars,$safeeval, $style_for_target);
  499: 	}
  500:       } else {
  501: 	&Apache::lonxml::error("Unknown token event :$token->[0]:$token->[1]:");
  502:       }
  503:       #evaluate variable refs in result
  504:       if ($Apache::lonxml::post_evaluate &&$result ne "") {
  505: 	  my $extras;
  506: 	  if (!$Apache::lonxml::usestyle) {
  507: 	      $extras=$Apache::lonxml::style_values;
  508: 	  }
  509: 	if ( $#$parstack > -1 ) {
  510: 	  $result=&Apache::run::evaluate($result,$safeeval,$extras.$$parstack[-1]);
  511: 	} else {
  512: 	  $result= &Apache::run::evaluate($result,$safeeval,$extras);
  513: 	}
  514:       }
  515:       $Apache::lonxml::post_evaluate=1;
  516: 
  517:       if (($token->[0] eq 'T') || ($token->[0] eq 'C') || ($token->[0] eq 'D') ) {
  518: 	  #Style file definitions should be correct
  519: 	  if ($target eq 'tex' && ($Apache::lonxml::usestyle)) {
  520: 	      $result=&latex_special_symbols($result);
  521: 	  }
  522:       }
  523: 
  524:       if ($Apache::lonxml::redirection) {
  525: 	$Apache::lonxml::outputstack['-1'] .= $result;
  526:       } else {
  527: 	$finaloutput.=$result;
  528:       }
  529:       $result = '';
  530: 
  531:       if ($token->[0] eq 'E' && !$dontpop) {
  532: 	&end_tag($stack,$parstack,$token);
  533:       }
  534:       $dontpop=0;
  535:     }	
  536:     if ($#$pars > -1) {
  537: 	pop @$pars;
  538: 	pop @Apache::lonxml::pwd;
  539:     }
  540:   }
  541: 
  542:   # if ($target eq 'meta') {
  543:   #   $finaloutput.=&endredirection;
  544:   # }
  545: 
  546: 
  547:   if (($ENV{'QUERY_STRING'}) && ($target eq 'web')) {
  548:     $finaloutput=&afterburn($finaloutput);
  549:   }	    
  550:   return $finaloutput;
  551: }
  552: 
  553: ## 
  554: ## Looks to see if there is a subroutine defined for this tag.  If so, call it,
  555: ## otherwise do not call it as we do not know what it is.
  556: ##
  557: sub callsub {
  558:   my ($sub,$target,$token,$tagstack,$parstack,$parser,$safeeval,$style)=@_;
  559:   my $currentstring='';
  560:   my $nodefault;
  561:   {
  562:     my $sub1;
  563:     no strict 'refs';
  564:     my $tag=$token->[1];
  565: # get utterly rid of extended html tags
  566:     if ($tag=~/^x\-/i) { return ''; }
  567:     my $space=$Apache::lonxml::alltags{$tag}[-1];
  568:     if (!$space) {
  569:      	$tag=~tr/A-Z/a-z/;
  570: 	$sub=~tr/A-Z/a-z/;
  571: 	$space=$Apache::lonxml::alltags{$tag}[-1]
  572:     }
  573: 
  574:     my $deleted=0;
  575:     $Apache::lonxml::curdepth=join('_',@Apache::lonxml::depthcounter);
  576:     if (($token->[0] eq 'S') && ($target eq 'modified')) {
  577:       $deleted=&Apache::edit::handle_delete($space,$target,$token,$tagstack,
  578: 					     $parstack,$parser,$safeeval,
  579: 					     $style);
  580:     }
  581:     if (!$deleted) {
  582:       if ($space) {
  583: 	#&Apache::lonxml::debug("Calling sub $sub in $space $metamode");
  584: 	$sub1="$space\:\:$sub";
  585: 	($currentstring,$nodefault) = &$sub1($target,$token,$tagstack,
  586: 					     $parstack,$parser,$safeeval,
  587: 					     $style);
  588:       } else {
  589:           if ($target eq 'tex') {
  590:               # throw away tag name
  591:               return '';
  592:           }
  593: 	#&Apache::lonxml::debug("NOT Calling sub $sub in $space $metamode");
  594: 	if ($metamode <1) {
  595: 	  if (defined($token->[4]) && ($metamode < 1)) {
  596: 	    $currentstring = $token->[4];
  597: 	  } else {
  598: 	    $currentstring = $token->[2];
  599: 	  }
  600: 	}
  601:       }
  602:       #    &Apache::lonxml::debug("nodefalt:$nodefault:");
  603:       if ($currentstring eq '' && $nodefault eq '') {
  604: 	if ($target eq 'edit') {
  605: 	  #&Apache::lonxml::debug("doing default edit for $token->[1]");
  606: 	  if ($token->[0] eq 'S') {
  607: 	    $currentstring = &Apache::edit::tag_start($target,$token);
  608: 	  } elsif ($token->[0] eq 'E') {
  609: 	    $currentstring = &Apache::edit::tag_end($target,$token);
  610: 	  }
  611: 	} elsif ($target eq 'modified') {
  612: 	  if ($token->[0] eq 'S') {
  613: 	    $currentstring = $token->[4];
  614: 	    $currentstring.=&Apache::edit::handle_insert();
  615: 	  } elsif ($token->[0] eq 'E') {
  616: 	    $currentstring = $token->[2];
  617:             $currentstring.=&Apache::edit::handle_insertafter($token->[1]);
  618: 	  } else {
  619: 	    $currentstring = $token->[2];
  620: 	  }
  621: 	}
  622:       }
  623:     }
  624:     use strict 'refs';
  625:   }
  626:   return $currentstring;
  627: }
  628: 
  629: sub setup_globals {
  630:   my ($request,$target)=@_;
  631:   $Apache::lonxml::request=$request;
  632:   $Apache::lonxml::registered = 0;
  633:   @Apache::lonxml::htmlareafields=();
  634:   $errorcount=0;
  635:   $warningcount=0;
  636:   $Apache::lonxml::default_homework_loaded=0;
  637:   $Apache::lonxml::usestyle=1;
  638:   &init_counter();
  639:   @Apache::lonxml::pwd=();
  640:   @Apache::lonxml::extlinks=();
  641:   @Apache::lonxml::ssi_info=();
  642:   $Apache::lonxml::post_evaluate=1;
  643:   $Apache::lonxml::warnings_error_header='';
  644:   if ($target eq 'meta') {
  645:     $Apache::lonxml::redirection = 0;
  646:     $Apache::lonxml::metamode = 1;
  647:     $Apache::lonxml::evaluate = 1;
  648:     $Apache::lonxml::import = 0;
  649:   } elsif ($target eq 'answer') {
  650:     $Apache::lonxml::redirection = 0;
  651:     $Apache::lonxml::metamode = 1;
  652:     $Apache::lonxml::evaluate = 1;
  653:     $Apache::lonxml::import = 1;
  654:   } elsif ($target eq 'grade') {
  655:     &startredirection;
  656:     $Apache::lonxml::metamode = 0;
  657:     $Apache::lonxml::evaluate = 1;
  658:     $Apache::lonxml::import = 1;
  659:   } elsif ($target eq 'modified') {
  660:     $Apache::lonxml::redirection = 0;
  661:     $Apache::lonxml::metamode = 0;
  662:     $Apache::lonxml::evaluate = 0;
  663:     $Apache::lonxml::import = 0;
  664:   } elsif ($target eq 'edit') {
  665:     $Apache::lonxml::redirection = 0;
  666:     $Apache::lonxml::metamode = 0;
  667:     $Apache::lonxml::evaluate = 0;
  668:     $Apache::lonxml::import = 0;
  669:   } elsif ($target eq 'analyze') {
  670:     $Apache::lonxml::redirection = 0;
  671:     $Apache::lonxml::metamode = 0;
  672:     $Apache::lonxml::evaluate = 1;
  673:     $Apache::lonxml::import = 1;
  674:   } else {
  675:     $Apache::lonxml::redirection = 0;
  676:     $Apache::lonxml::metamode = 0;
  677:     $Apache::lonxml::evaluate = 1;
  678:     $Apache::lonxml::import = 1;
  679:   }
  680: }
  681: 
  682: sub init_safespace {
  683:   my ($target,$safeeval,$safehole,$safeinit) = @_;
  684:   $safeeval->permit("entereval");
  685:   $safeeval->permit(":base_math");
  686:   $safeeval->permit("sort");
  687:   $safeeval->permit("time");
  688:   $safeeval->deny(":base_io");
  689:   $safehole->wrap(\&Apache::scripttag::xmlparse,$safeeval,'&xmlparse');
  690:   $safehole->wrap(\&Apache::outputtags::multipart,$safeeval,'&multipart');
  691:   $safehole->wrap(\&Apache::lonnet::EXT,$safeeval,'&EXT');
  692:   $safehole->wrap(\&Apache::chemresponse::chem_standard_order,$safeeval,
  693: 		  '&chem_standard_order');
  694: 
  695:   $safehole->wrap(\&Math::Cephes::asin,$safeeval,'&asin');
  696:   $safehole->wrap(\&Math::Cephes::acos,$safeeval,'&acos');
  697:   $safehole->wrap(\&Math::Cephes::atan,$safeeval,'&atan');
  698:   $safehole->wrap(\&Math::Cephes::sinh,$safeeval,'&sinh');
  699:   $safehole->wrap(\&Math::Cephes::cosh,$safeeval,'&cosh');
  700:   $safehole->wrap(\&Math::Cephes::tanh,$safeeval,'&tanh');
  701:   $safehole->wrap(\&Math::Cephes::asinh,$safeeval,'&asinh');
  702:   $safehole->wrap(\&Math::Cephes::acosh,$safeeval,'&acosh');
  703:   $safehole->wrap(\&Math::Cephes::atanh,$safeeval,'&atanh');
  704:   $safehole->wrap(\&Math::Cephes::erf,$safeeval,'&erf');
  705:   $safehole->wrap(\&Math::Cephes::erfc,$safeeval,'&erfc');
  706:   $safehole->wrap(\&Math::Cephes::j0,$safeeval,'&j0');
  707:   $safehole->wrap(\&Math::Cephes::j1,$safeeval,'&j1');
  708:   $safehole->wrap(\&Math::Cephes::jn,$safeeval,'&jn');
  709:   $safehole->wrap(\&Math::Cephes::jv,$safeeval,'&jv');
  710:   $safehole->wrap(\&Math::Cephes::y0,$safeeval,'&y0');
  711:   $safehole->wrap(\&Math::Cephes::y1,$safeeval,'&y1');
  712:   $safehole->wrap(\&Math::Cephes::yn,$safeeval,'&yn');
  713:   $safehole->wrap(\&Math::Cephes::yv,$safeeval,'&yv');
  714:   
  715:   $safehole->wrap(\&Math::Cephes::bdtr  ,$safeeval,'&bdtr'  );
  716:   $safehole->wrap(\&Math::Cephes::bdtrc ,$safeeval,'&bdtrc' );
  717:   $safehole->wrap(\&Math::Cephes::bdtri ,$safeeval,'&bdtri' );
  718:   $safehole->wrap(\&Math::Cephes::btdtr ,$safeeval,'&btdtr' );
  719:   $safehole->wrap(\&Math::Cephes::chdtr ,$safeeval,'&chdtr' );
  720:   $safehole->wrap(\&Math::Cephes::chdtrc,$safeeval,'&chdtrc');
  721:   $safehole->wrap(\&Math::Cephes::chdtri,$safeeval,'&chdtri');
  722:   $safehole->wrap(\&Math::Cephes::fdtr  ,$safeeval,'&fdtr'  );
  723:   $safehole->wrap(\&Math::Cephes::fdtrc ,$safeeval,'&fdtrc' );
  724:   $safehole->wrap(\&Math::Cephes::fdtri ,$safeeval,'&fdtri' );
  725:   $safehole->wrap(\&Math::Cephes::gdtr  ,$safeeval,'&gdtr'  );
  726:   $safehole->wrap(\&Math::Cephes::gdtrc ,$safeeval,'&gdtrc' );
  727:   $safehole->wrap(\&Math::Cephes::nbdtr ,$safeeval,'&nbdtr' );
  728:   $safehole->wrap(\&Math::Cephes::nbdtrc,$safeeval,'&nbdtrc');
  729:   $safehole->wrap(\&Math::Cephes::nbdtri,$safeeval,'&nbdtri');
  730:   $safehole->wrap(\&Math::Cephes::ndtr  ,$safeeval,'&ndtr'  );
  731:   $safehole->wrap(\&Math::Cephes::ndtri ,$safeeval,'&ndtri' );
  732:   $safehole->wrap(\&Math::Cephes::pdtr  ,$safeeval,'&pdtr'  );
  733:   $safehole->wrap(\&Math::Cephes::pdtrc ,$safeeval,'&pdtrc' );
  734:   $safehole->wrap(\&Math::Cephes::pdtri ,$safeeval,'&pdtri' );
  735:   $safehole->wrap(\&Math::Cephes::stdtr ,$safeeval,'&stdtr' );
  736:   $safehole->wrap(\&Math::Cephes::stdtri,$safeeval,'&stdtri');
  737: 
  738: #  $safehole->wrap(\&Math::Cephes::new_fract,$safeeval,'&new_fract');
  739: #  $safehole->wrap(\&Math::Cephes::radd,$safeeval,'&radd');
  740: #  $safehole->wrap(\&Math::Cephes::rsub,$safeeval,'&rsub');
  741: #  $safehole->wrap(\&Math::Cephes::rmul,$safeeval,'&rmul');
  742: #  $safehole->wrap(\&Math::Cephes::rdiv,$safeeval,'&rdiv');
  743: #  $safehole->wrap(\&Math::Cephes::euclid,$safeeval,'&euclid');
  744: 
  745:   $safehole->wrap(\&Math::Random::random_beta,$safeeval,'&math_random_beta');
  746:   $safehole->wrap(\&Math::Random::random_chi_square,$safeeval,'&math_random_chi_square');
  747:   $safehole->wrap(\&Math::Random::random_exponential,$safeeval,'&math_random_exponential');
  748:   $safehole->wrap(\&Math::Random::random_f,$safeeval,'&math_random_f');
  749:   $safehole->wrap(\&Math::Random::random_gamma,$safeeval,'&math_random_gamma');
  750:   $safehole->wrap(\&Math::Random::random_multivariate_normal,$safeeval,'&math_random_multivariate_normal');
  751:   $safehole->wrap(\&Math::Random::random_multinomial,$safeeval,'&math_random_multinomial');
  752:   $safehole->wrap(\&Math::Random::random_noncentral_chi_square,$safeeval,'&math_random_noncentral_chi_square');
  753:   $safehole->wrap(\&Math::Random::random_noncentral_f,$safeeval,'&math_random_noncentral_f');
  754:   $safehole->wrap(\&Math::Random::random_normal,$safeeval,'&math_random_normal');
  755:   $safehole->wrap(\&Math::Random::random_permutation,$safeeval,'&math_random_permutation');
  756:   $safehole->wrap(\&Math::Random::random_permuted_index,$safeeval,'&math_random_permuted_index');
  757:   $safehole->wrap(\&Math::Random::random_uniform,$safeeval,'&math_random_uniform');
  758:   $safehole->wrap(\&Math::Random::random_poisson,$safeeval,'&math_random_poisson');
  759:   $safehole->wrap(\&Math::Random::random_uniform_integer,$safeeval,'&math_random_uniform_integer');
  760:   $safehole->wrap(\&Math::Random::random_negative_binomial,$safeeval,'&math_random_negative_binomial');
  761:   $safehole->wrap(\&Math::Random::random_binomial,$safeeval,'&math_random_binomial');
  762:   $safehole->wrap(\&Math::Random::random_seed_from_phrase,$safeeval,'&random_seed_from_phrase');
  763:   $safehole->wrap(\&Math::Random::random_set_seed_from_phrase,$safeeval,'&random_set_seed_from_phrase');
  764:   $safehole->wrap(\&Math::Random::random_get_seed,$safeeval,'&random_get_seed');
  765:   $safehole->wrap(\&Math::Random::random_set_seed,$safeeval,'&random_set_seed');
  766:   $safehole->wrap(\&Apache::lonxml::error,$safeeval,'&LONCAPA_INTERNAL_ERROR');
  767:   $safehole->wrap(\&Apache::lonxml::debug,$safeeval,'&LONCAPA_INTERNAL_DEBUG');
  768:   $safehole->wrap(\&Apache::caparesponse::get_sigrange,$safeeval,'&LONCAPA_INTERNAL_get_sigrange');
  769: 
  770: #need to inspect this class of ops
  771: # $safeeval->deny(":base_orig");
  772:   $safeeval->permit("require");
  773:   $safeinit .= ';$external::target="'.$target.'";';
  774:   my $rndseed;
  775:   my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
  776:   $rndseed=&Apache::lonnet::rndseed($symb,$courseid,$domain,$name);
  777:   $safeinit .= ';$external::randomseed="'.$rndseed.'";';
  778:   &Apache::lonxml::debug("Setting rndseed to $rndseed");
  779:   &Apache::run::run($safeinit,$safeeval);
  780: 
  781: }
  782: 
  783: sub default_homework_load {
  784:     my ($safeeval)=@_;
  785:     &Apache::lonxml::debug('Loading default_homework');
  786:     my $default=&Apache::lonnet::getfile('/home/httpd/html/res/adm/includes/default_homework.lcpm');
  787:     if ($default eq -1) {
  788: 	&Apache::lonxml::error("<b>Unable to find <i>default_homework.lcpm</i></b>");
  789:     } else {
  790: 	&Apache::run::run($default,$safeeval);
  791: 	$Apache::lonxml::default_homework_loaded=1;
  792:     }
  793: }
  794: 
  795: my $metamode_was;
  796: sub startredirection {
  797:     if (!$Apache::lonxml::redirection) {
  798: 	$metamode_was=$Apache::lonxml::metamode;
  799:     }
  800:     $Apache::lonxml::metamode=0;
  801:     $Apache::lonxml::redirection++;
  802:     push (@Apache::lonxml::outputstack, '');
  803: }
  804: 
  805: sub endredirection {
  806:     if (!$Apache::lonxml::redirection) {
  807: 	&Apache::lonxml::error("Endredirection was called, before a startredirection, perhaps you have unbalanced tags. Some debuging information:".join ":",caller);
  808: 	return '';
  809:     }
  810:     $Apache::lonxml::redirection--;
  811:     if (!$Apache::lonxml::redirection) {
  812: 	$Apache::lonxml::metamode=$metamode_was;
  813:     }
  814:     pop @Apache::lonxml::outputstack;
  815: }
  816: 
  817: sub end_tag {
  818:   my ($tagstack,$parstack,$token)=@_;
  819:   pop(@$tagstack);
  820:   pop(@$parstack);
  821:   &decreasedepth($token);
  822: }
  823: 
  824: sub initdepth {
  825:   @Apache::lonxml::depthcounter=();
  826:   $Apache::lonxml::depth=-1;
  827:   $Apache::lonxml::olddepth=-1;
  828: }
  829: 
  830: my @timers;
  831: my $lasttime;
  832: sub increasedepth {
  833:   my ($token) = @_;
  834:   $Apache::lonxml::depth++;
  835:   $Apache::lonxml::depthcounter[$Apache::lonxml::depth]++;
  836:   if ($Apache::lonxml::depthcounter[$Apache::lonxml::depth]==1) {
  837:     $Apache::lonxml::olddepth=$Apache::lonxml::depth;
  838:   }
  839:   my $time;
  840:   if ($Apache::lonxml::debug eq "1") {
  841:       push(@timers,[&gettimeofday()]);
  842:       $time=&tv_interval($lasttime);
  843:       $lasttime=[&gettimeofday()];
  844:   }
  845:   my $spacing='  'x($Apache::lonxml::depth-1);
  846:   my $curdepth=join('_',@Apache::lonxml::depthcounter);
  847:   &Apache::lonxml::debug("s$spacing$Apache::lonxml::depth : $Apache::lonxml::olddepth : $curdepth : $token->[1] : $time : \n");
  848: #print "<br />s $Apache::lonxml::depth : $Apache::lonxml::olddepth : $curdepth : $token->[1]\n";
  849: }
  850: 
  851: sub decreasedepth {
  852:   my ($token) = @_;
  853:   $Apache::lonxml::depth--;
  854:   if ($Apache::lonxml::depth<$Apache::lonxml::olddepth-1) {
  855:     $#Apache::lonxml::depthcounter--;
  856:     $Apache::lonxml::olddepth=$Apache::lonxml::depth+1;
  857:   }
  858:   if (  $Apache::lonxml::depth < -1) {
  859:     &Apache::lonxml::warning(&mt("Missing tags, unable to properly run file."));
  860:     $Apache::lonxml::depth='-1';
  861:   }
  862:   my ($timer,$time);
  863:   if ($Apache::lonxml::debug eq "1") {
  864:       $timer=pop(@timers);
  865:       $time=&tv_interval($lasttime);
  866:       $lasttime=[&gettimeofday()];
  867:   }
  868:   my $spacing='  'x$Apache::lonxml::depth;
  869:   my $curdepth=join('_',@Apache::lonxml::depthcounter);
  870:   &Apache::lonxml::debug("e$spacing$Apache::lonxml::depth : $Apache::lonxml::olddepth : $curdepth : $token->[1] : $time : ".&tv_interval($timer)."\n");
  871: #print "<br />e $Apache::lonxml::depth : $Apache::lonxml::olddepth : $token->[1] : $curdepth\n";
  872: }
  873: 
  874: sub get_all_text_unbalanced {
  875: #there is a copy of this in lonpublisher.pm
  876:     my($tag,$pars)= @_;
  877:     my $token;
  878:     my $result='';
  879:     $tag='<'.$tag.'>';
  880:     while ($token = $$pars[-1]->get_token) {
  881: 	if (($token->[0] eq 'T')||($token->[0] eq 'C')||($token->[0] eq 'D')) {
  882: 	    $result.=$token->[1];
  883: 	} elsif ($token->[0] eq 'PI') {
  884: 	    $result.=$token->[2];
  885: 	} elsif ($token->[0] eq 'S') {
  886: 	    $result.=$token->[4];
  887: 	} elsif ($token->[0] eq 'E')  {
  888: 	    $result.=$token->[2];
  889: 	}
  890: 	if ($result =~ /\Q$tag\E/is) {
  891: 	    ($result,my $redo)=$result =~ /(.*)\Q$tag\E(.*)/is;
  892: 	    #&Apache::lonxml::debug('Got a winner with leftovers ::'.$2);
  893: 	    #&Apache::lonxml::debug('Result is :'.$1);
  894: 	    $redo=$tag.$redo;
  895: 	    &Apache::lonxml::newparser($pars,\$redo);
  896: 	    last;
  897: 	}
  898:     }
  899:     return $result
  900: }
  901: 
  902: sub increment_counter {
  903:     my ($increment) = @_;
  904:     if (defined($increment) && $increment gt 0) {
  905: 	$Apache::lonxml::counter+=$increment;
  906:     } else {
  907: 	$Apache::lonxml::counter++;
  908:     }
  909:     $Apache::lonxml::counter_changed=1;
  910: }
  911: 
  912: sub init_counter {
  913:     if (defined($ENV{'form.counter'})) {
  914: 	$Apache::lonxml::counter=$ENV{'form.counter'};
  915: 	$Apache::lonxml::counter_changed=0;
  916:     } else {
  917: 	$Apache::lonxml::counter=1;
  918: 	$Apache::lonxml::counter_changed=1;
  919:     }
  920: }
  921: 
  922: sub store_counter {
  923:     &Apache::lonnet::appenv(('form.counter' => $Apache::lonxml::counter));
  924:     return '';
  925: }
  926: 
  927: sub get_all_text {
  928:     my($tag,$pars,$style)= @_;
  929:     my $gotfullstack=1;
  930:     if (ref($pars) ne 'ARRAY') {
  931: 	$gotfullstack=0;
  932: 	$pars=[$pars];
  933:     }
  934:     if (ref($style) ne 'HASH') {
  935: 	$style={};
  936:     }
  937:     my $depth=0;
  938:     my $token;
  939:     my $result='';
  940:     if ( $tag =~ m:^/: ) { 
  941: 	my $tag=substr($tag,1); 
  942: 	#&Apache::lonxml::debug("have:$tag:");
  943: 	my $top_empty=0;
  944: 	while (($depth >=0) && ($#$pars > -1) && (!$top_empty)) {
  945: 	    while (($depth >=0) && ($token = $$pars[-1]->get_token)) {
  946: 		#&Apache::lonxml::debug("e token:$token->[0]:$depth:$token->[1]:".$#$pars.":".$#Apache::lonxml::pwd);
  947: 		if (($token->[0] eq 'T')||($token->[0] eq 'C')||($token->[0] eq 'D')) {
  948: 		    $result.=$token->[1];
  949: 		} elsif ($token->[0] eq 'PI') {
  950: 		    $result.=$token->[2];
  951: 		} elsif ($token->[0] eq 'S') {
  952: 		    if ($token->[1] =~ /^\Q$tag\E$/i) { $depth++; }
  953: 		    if ($token->[1] =~ /^LONCAPA_INTERNAL_TURN_STYLE_ON$/) { $Apache::lonxml::usestyle=1; }
  954: 		    if ($token->[1] =~ /^LONCAPA_INTERNAL_TURN_STYLE_OFF$/) { $Apache::lonxml::usestyle=0; }
  955: 		    $result.=$token->[4];
  956: 		} elsif ($token->[0] eq 'E')  {
  957: 		    if ( $token->[1] =~ /^\Q$tag\E$/i) { $depth--; }
  958: 		    #skip sending back the last end tag
  959: 		    if ($depth == 0 && exists($$style{'/'.$token->[1]}) && $Apache::lonxml::usestyle) {
  960: 			my $string=
  961: 			    '<LONCAPA_INTERNAL_TURN_STYLE_OFF end="yes" />'.
  962: 				$$style{'/'.$token->[1]}.
  963: 				    $token->[2].
  964: 					'<LONCAPA_INTERNAL_TURN_STYLE_ON />';
  965: 			&Apache::lonxml::newparser($pars,\$string);
  966: 			#&Apache::lonxml::debug("reParsing $string");
  967: 			next;
  968: 		    }
  969: 		    if ($depth > -1) {
  970: 			$result.=$token->[2];
  971: 		    } else {
  972: 			$$pars[-1]->unget_token($token);
  973: 		    }
  974: 		}
  975: 	    }
  976: 	    if (($depth >=0) && ($#$pars == 0) ) { $top_empty=1; }
  977: 	    if (($depth >=0) && ($#$pars > 0) ) {
  978: 		pop(@$pars);
  979: 		pop(@Apache::lonxml::pwd);
  980: 	    }
  981: 	}
  982: 	if ($top_empty && $depth >= 0) {
  983: 	    #never found the end tag ran out of text, throw error send back blank
  984: 	    &error('Never found end tag for &lt;'.$tag.
  985: 		   '&gt; current string <pre>'.
  986: 		   &HTML::Entities::encode($result,'<>&"').
  987: 		   '</pre>');
  988: 	    if ($gotfullstack) {
  989: 		my $newstring='</'.$tag.'>'.$result;
  990: 		&Apache::lonxml::newparser($pars,\$newstring);
  991: 	    }
  992: 	    $result='';
  993: 	}
  994:     } else {
  995: 	while ($#$pars > -1) {
  996: 	    while ($token = $$pars[-1]->get_token) {
  997: 		#&Apache::lonxml::debug("s token:$token->[0]:$depth:$token->[1]");
  998: 		if (($token->[0] eq 'T')||($token->[0] eq 'C')||
  999: 		    ($token->[0] eq 'D')) {
 1000: 		    $result.=$token->[1];
 1001: 		} elsif ($token->[0] eq 'PI') {
 1002: 		    $result.=$token->[2];
 1003: 		} elsif ($token->[0] eq 'S') {
 1004: 		    if ( $token->[1] =~ /^\Q$tag\E$/i) {
 1005: 			$$pars[-1]->unget_token($token); last;
 1006: 		    } else {
 1007: 			$result.=$token->[4];
 1008: 		    }
 1009: 		    if ($token->[1] =~ /^LONCAPA_INTERNAL_TURN_STYLE_ON$/) { $Apache::lonxml::usestyle=1; }
 1010: 		    if ($token->[1] =~ /^LONCAPA_INTERNAL_TURN_STYLE_OFF$/) { $Apache::lonxml::usestyle=0; }
 1011: 		} elsif ($token->[0] eq 'E')  {
 1012: 		    $result.=$token->[2];
 1013: 		}
 1014: 	    }
 1015: 	    if (($#$pars > 0) ) {
 1016: 		pop(@$pars);
 1017: 		pop(@Apache::lonxml::pwd);
 1018: 	    } else { last; }
 1019: 	}
 1020:     }
 1021:     #&Apache::lonxml::debug("Exit:$result:");
 1022:     return $result
 1023: }
 1024: 
 1025: sub newparser {
 1026:   my ($parser,$contentref,$dir) = @_;
 1027:   push (@$parser,HTML::LCParser->new($contentref));
 1028:   $$parser['-1']->xml_mode('1');
 1029:   if ( $dir eq '' ) {
 1030:     push (@Apache::lonxml::pwd, $Apache::lonxml::pwd[$#Apache::lonxml::pwd]);
 1031:   } else {
 1032:     push (@Apache::lonxml::pwd, $dir);
 1033:   } 
 1034: }
 1035: 
 1036: sub parstring {
 1037:   my ($token) = @_;
 1038:   my $temp='';
 1039:   foreach (@{$token->[3]}) {
 1040:     unless ($_=~/\W/) {
 1041:       my $val=$token->[2]->{$_};
 1042:       $val =~ s/([\%\@\\\"\'])/\\$1/g;
 1043:       $val =~ s/(\$[^{a-zA-Z_])/\\$1/g;
 1044:       $val =~ s/(\$)$/\\$1/;
 1045:       #if ($val =~ m/^[\%\@]/) { $val="\\".$val; }
 1046:       $temp .= "my \$$_=\"$val\";";
 1047:     }
 1048:   }
 1049:   return $temp;
 1050: }
 1051: 
 1052: sub writeallows {
 1053:     unless ($#extlinks>=0) { return; }
 1054:     my $thisurl='/res/'.&Apache::lonnet::declutter(shift);
 1055:     if ($ENV{'httpref.'.$thisurl}) {
 1056: 	$thisurl=$ENV{'httpref.'.$thisurl};
 1057:     }
 1058:     my $thisdir=$thisurl;
 1059:     $thisdir=~s/\/[^\/]+$//;
 1060:     my %httpref=();
 1061:     foreach (@extlinks) {
 1062:        $httpref{'httpref.'.
 1063:  	        &Apache::lonnet::hreflocation($thisdir,$_)}=$thisurl;
 1064:     }
 1065:     @extlinks=();
 1066:     &Apache::lonnet::appenv(%httpref);
 1067: }
 1068: 
 1069: sub register_ssi {
 1070:     my ($url,%form)=@_;
 1071:     push (@Apache::lonxml::ssi_info,{'url'=>$url,'form'=>\%form});
 1072:     return '';
 1073: }
 1074: 
 1075: sub do_registered_ssi {
 1076:     foreach my $info (@Apache::lonxml::ssi_info) {
 1077: 	my %form=%{ $info->{'form'}};
 1078: 	my $url=$info->{'url'};
 1079: 	&Apache::lonnet::ssi($url,%form);
 1080:     }
 1081: }
 1082: #
 1083: # Afterburner handles anchors, highlights and links
 1084: #
 1085: sub afterburn {
 1086:     my $result=shift;
 1087:     &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},
 1088: 					    ['highlight','anchor','link']);
 1089:     if ($ENV{'form.highlight'}) {
 1090:        foreach (split(/\,/,$ENV{'form.highlight'})) {
 1091:            my $anchorname=$_;
 1092: 	   my $matchthis=$anchorname;
 1093:            $matchthis=~s/\_+/\\s\+/g;
 1094:            $result=~s/(\Q$matchthis\E)/\<font color=\"red\"\>$1\<\/font\>/gs;
 1095:        }
 1096:     }
 1097:     if ($ENV{'form.link'}) {
 1098:        foreach (split(/\,/,$ENV{'form.link'})) {
 1099:            my ($anchorname,$linkurl)=split(/\>/,$_);
 1100: 	   my $matchthis=$anchorname;
 1101:            $matchthis=~s/\_+/\\s\+/g;
 1102:            $result=~s/(\Q$matchthis\E)/\<a href=\"$linkurl\"\>$1\<\/a\>/gs;
 1103:        }
 1104:     }
 1105:     if ($ENV{'form.anchor'}) {
 1106:         my $anchorname=$ENV{'form.anchor'};
 1107: 	my $matchthis=$anchorname;
 1108:         $matchthis=~s/\_+/\\s\+/g;
 1109:         $result=~s/(\Q$matchthis\E)/\<a name=\"$anchorname\"\>$1\<\/a\>/s;
 1110:         $result.=(<<"ENDSCRIPT");
 1111: <script type="text/javascript">
 1112:     document.location.hash='$anchorname';
 1113: </script>
 1114: ENDSCRIPT
 1115:     }
 1116:     return $result;
 1117: }
 1118: 
 1119: sub storefile {
 1120:     my ($file,$contents)=@_;
 1121:     &Apache::lonnet::correct_line_ends(\$contents);
 1122:     if (my $fh=Apache::File->new('>'.$file)) {
 1123: 	print $fh $contents;
 1124:         $fh->close();
 1125:         return 1;
 1126:     } else {
 1127: 	&warning("Unable to save file $file");
 1128: 	return 0;
 1129:     }
 1130: }
 1131: 
 1132: sub createnewhtml {
 1133:     my $title=&mt('Title of document goes here');
 1134:     my $body=&mt('Body of document goes here');
 1135:     my $filecontents=(<<SIMPLECONTENT);
 1136: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml/11/DTD/xhtml11.dtd">
 1137: <html>
 1138: <head>
 1139: <title>$title</title>
 1140: </head>
 1141: <body bgcolor="#FFFFFF">
 1142: $body
 1143: </body>
 1144: </html>
 1145: SIMPLECONTENT
 1146:     return $filecontents;
 1147: }
 1148: 
 1149: sub createnewsty {
 1150:   my $filecontents=(<<SIMPLECONTENT);
 1151: <definetag name="">
 1152:     <render>
 1153:        <web></web>
 1154:        <tex></tex>
 1155:     </render>
 1156: </definetag>
 1157: SIMPLECONTENT
 1158:   return $filecontents;
 1159: }
 1160: 
 1161: 
 1162: sub inserteditinfo {
 1163:       my ($result,$filecontents,$filetype)=@_;
 1164:       $filecontents = &HTML::Entities::encode($filecontents,'<>&"');
 1165: #      my $editheader='<a href="#editsection">Edit below</a><hr />';
 1166:       my $xml_help = '';
 1167:       my $initialize='';
 1168:       if ($filetype eq 'html') {
 1169: 	  my $addbuttons=&Apache::lonhtmlcommon::htmlareaaddbuttons();
 1170: 	  $initialize=&Apache::lonhtmlcommon::htmlareaheaders().
 1171: 	      &Apache::lonhtmlcommon::spellheader();
 1172: 	  if (!&Apache::lonhtmlcommon::htmlareablocked() &&
 1173: 	      &Apache::lonhtmlcommon::htmlareabrowser()) {
 1174: 	      $initialize.=(<<FULLPAGE);
 1175: <script type="text/javascript">
 1176: $addbuttons
 1177: 
 1178:     HTMLArea.loadPlugin("FullPage");
 1179: 
 1180:     function initDocument() {
 1181: 	var editor=new HTMLArea("filecont",config);
 1182: 	editor.registerPlugin(FullPage);
 1183: 	editor.generate();
 1184:     }
 1185: </script>
 1186: FULLPAGE
 1187:           } else {
 1188: 	      $initialize.=(<<FULLPAGE);
 1189: <script type="text/javascript">
 1190: $addbuttons
 1191:     function initDocument() {
 1192:     }
 1193: </script>
 1194: FULLPAGE
 1195: 	  }
 1196:           $result=~s/\<body([^\>]*)\>/\<body onload="initDocument()" $1\>/i;
 1197: 	  $xml_help=&Apache::loncommon::helpLatexCheatsheet();
 1198:       }
 1199:       my $cleanbut = '';
 1200:       if ($filetype eq 'html') {
 1201: 	  $cleanbut='<input type="submit" name="attemptclean" value="'.
 1202: 	      &mt('Save and then attempt to clean HTML').'" />';
 1203:       }
 1204:       my $titledisplay=&display_title();
 1205:       my %lt=&Apache::lonlocal::texthash('st' => 'Save this',
 1206: 					 'vi' => 'View',
 1207: 					 'ed' => 'Edit');
 1208:       my $buttons=(<<BUTTONS);
 1209: $cleanbut
 1210: <input type="submit" name="savethisfile" accesskey="s"  value="$lt{'st'}" />
 1211: <input type="submit" name="viewmode" accesskey="v" value="$lt{'vi'}" />
 1212: BUTTONS
 1213:       $buttons.=&Apache::lonhtmlcommon::spelllink('xmledit','filecont');
 1214:       $buttons.=&Apache::lonhtmlcommon::htmlareaselectactive('filecont');
 1215:       my $editfooter=(<<ENDFOOTER);
 1216: $initialize
 1217: <hr />
 1218: <a name="editsection" />
 1219: <form method="post" name="xmledit">
 1220: $xml_help
 1221: <input type="hidden" name="editmode" value="$lt{'ed'}" />
 1222: $buttons<br />
 1223: <textarea cols="80" rows="44" name="filecont" id="filecont">$filecontents</textarea>
 1224: <br />$buttons
 1225: <br />
 1226: </form>
 1227: $titledisplay
 1228: </body>
 1229: ENDFOOTER
 1230: #      $result=~s/(\<body[^\>]*\>)/$1$editheader/is;
 1231:       $result=~s/(\<\/body\>)/$editfooter/is;
 1232:       return $result;
 1233: }
 1234: 
 1235: sub get_target {
 1236:   my $viewgrades=&Apache::lonnet::allowed('vgr',$ENV{'request.course.id'});
 1237:   if ( $ENV{'request.state'} eq 'published') {
 1238:     if ( defined($ENV{'form.grade_target'})
 1239: 	 && ($viewgrades == 'F' )) {
 1240:       return ($ENV{'form.grade_target'});
 1241:     } elsif (defined($ENV{'form.grade_target'})) {
 1242:       if (($ENV{'form.grade_target'} eq 'web') ||
 1243: 	  ($ENV{'form.grade_target'} eq 'tex') ) {
 1244: 	return $ENV{'form.grade_target'}
 1245:       } else {
 1246: 	return 'web';
 1247:       }
 1248:     } else {
 1249:       return 'web';
 1250:     }
 1251:   } elsif ($ENV{'request.state'} eq 'construct') {
 1252:     if ( defined($ENV{'form.grade_target'})) {
 1253:       return ($ENV{'form.grade_target'});
 1254:     } else {
 1255:       return 'web';
 1256:     }
 1257:   } else {
 1258:     return 'web';
 1259:   }
 1260: }
 1261: 
 1262: sub handler {
 1263:     my $request=shift;
 1264:     
 1265:     my $target=&get_target();
 1266:     
 1267:     $Apache::lonxml::debug=$ENV{'user.debug'};
 1268:     
 1269:     if ($ENV{'browser.mathml'}) {
 1270: 	&Apache::loncommon::content_type($request,'text/xml');
 1271:     } else {
 1272: 	&Apache::loncommon::content_type($request,'text/html');
 1273:     }
 1274:     &Apache::loncommon::no_cache($request);
 1275:     $request->set_last_modified(&Apache::lonnet::metadata($request->uri,
 1276: 							  'lastrevisiondate'));
 1277:     $request->send_http_header;
 1278:     
 1279:     return OK if $request->header_only;
 1280: 
 1281: 
 1282:     my $file=&Apache::lonnet::filelocation("",$request->uri);
 1283:     my $filetype;
 1284:     if ($file =~ /\.sty$/) {
 1285: 	$filetype='sty';
 1286:     } else {
 1287: 	$filetype='html';
 1288:     }
 1289: #
 1290: # Edit action? Save file.
 1291: #
 1292:     unless ($ENV{'request.state'} eq 'published') {
 1293: 	if (($ENV{'form.savethisfile'}) || ($ENV{'form.attemptclean'})) {
 1294: 	    if (&storefile($file,$ENV{'form.filecont'})) {
 1295: 		&Apache::lonxml::info("<font COLOR=\"#0000FF\">".
 1296: 				      &mt('Updated').": ".
 1297: 				      &Apache::lonlocal::locallocaltime(time).
 1298: 				      " </font>");
 1299: 	    } 
 1300: 	}
 1301:     }
 1302:     my %mystyle;
 1303:     my $result = '';
 1304:     my $filecontents=&Apache::lonnet::getfile($file);
 1305:     if ($filecontents eq -1) {
 1306: 	my $bodytag=&Apache::loncommon::bodytag('File Error');
 1307: 	my $fnf=&mt('File not found');
 1308: 	$result=(<<ENDNOTFOUND);
 1309: <html>
 1310: <head>
 1311: <title>$fnf</title>
 1312: </head>
 1313: $bodytag
 1314: <b>$fnf: $file</b>
 1315: </body>
 1316: </html>
 1317: ENDNOTFOUND
 1318:         $filecontents='';
 1319: 	if ($ENV{'request.state'} ne 'published') {
 1320: 	    if ($filetype eq 'sty') {
 1321: 		$filecontents=&createnewsty();
 1322: 	    } else {
 1323: 		$filecontents=&createnewhtml();
 1324: 	    }
 1325: 	    $ENV{'form.editmode'}='Edit'; #force edit mode
 1326: 	}
 1327:     } else {
 1328: 	unless ($ENV{'request.state'} eq 'published') {
 1329: 	    if ($filecontents=~/BEGIN LON-CAPA Internal/) {
 1330: 		&Apache::lonxml::error(&mt('This file appears to be a rendering of a Lon-CAPA resource. If this is correct, this resource will act very oddly and incorrectly.'));
 1331: 	    }
 1332: 
 1333: 	    if ($ENV{'form.attemptclean'}) {
 1334: 		$filecontents=&htmlclean($filecontents,1);
 1335: 	    }
 1336: #
 1337: # we are in construction space, see if edit mode forced
 1338:             &Apache::loncommon::get_unprocessed_cgi
 1339:                           ($ENV{'QUERY_STRING'},['editmode']);
 1340: 	}
 1341: 	if (!$ENV{'form.editmode'} || $ENV{'form.viewmode'}) {
 1342: 	    $result = &Apache::lonxml::xmlparse($request,$target,$filecontents,
 1343: 						'',%mystyle);
 1344: 	}
 1345:     }
 1346:     
 1347: #
 1348: # Edit action? Insert editing commands
 1349: #
 1350:     unless ($ENV{'request.state'} eq 'published') {
 1351: 	if ($ENV{'form.editmode'} && (!($ENV{'form.viewmode'}))) {
 1352: 	    my $displayfile=$request->uri;
 1353: 	    $displayfile=~s/^\/[^\/]*//;
 1354: 	    my $bodytag='<body bgcolor="#FFFFFF">';
 1355: 	    if ($ENV{'environment.remote'} eq 'off') {
 1356: 		$bodytag=&Apache::loncommon::bodytag();
 1357: 	    }
 1358: 	    $result='<html>'.$bodytag.
 1359: 		&Apache::lonxml::message_location().'<h3>'.
 1360: 		$displayfile.
 1361: 		'</h3></body></html>';
 1362: 	    $result=&inserteditinfo($result,$filecontents,$filetype);
 1363: 	}
 1364:     }
 1365:     if ($filetype eq 'html') { writeallows($request->uri); }
 1366: 	
 1367:     
 1368:     &Apache::lonxml::add_messages(\$result);
 1369:     $request->print($result);
 1370:     
 1371:     return OK;
 1372: }
 1373: 
 1374: sub display_title {
 1375:     my $result;
 1376:     if ($ENV{'request.state'} eq 'construct') {
 1377: 	my $title=&Apache::lonnet::gettitle();
 1378: 	if (!defined($title) || $title eq '') {
 1379: 	    $title = $ENV{'request.filename'};
 1380: 	    $title = substr($title, rindex($title, '/') + 1);
 1381: 	}
 1382: 	$result = "<script type='text/javascript'>top.document.title = '$title - LON-CAPA Construction Space';</script>";
 1383:     }
 1384:     return $result;
 1385: }
 1386: 
 1387: sub debug {
 1388:     if ($Apache::lonxml::debug eq "1") {
 1389: 	$|=1;
 1390: 	my $request=$Apache::lonxml::request;
 1391: 	if (!$request) { $request=Apache->request; }
 1392: 	$request->print('<font size="-2"><pre>DEBUG:'.&HTML::Entities::encode($_[0],'<>&"')."</pre></font>\n");
 1393: 	#&Apache::lonnet::logthis($_[0]);
 1394:     }
 1395: }
 1396: 
 1397: sub show_error_warn_msg {
 1398:     if ($ENV{'request.filename'} eq '/home/httpd/html/res/lib/templates/simpleproblem.problem' &&
 1399: 	&Apache::lonnet::allowed('mdc',$ENV{'request.course.id'})) {
 1400: 	return 1;
 1401:     }
 1402:     return (($Apache::lonxml::debug eq 1) ||
 1403: 	    ($ENV{'request.state'} eq 'construct') ||
 1404: 	    ($Apache::lonhomework::browse eq 'F'
 1405: 	     &&
 1406: 	     $ENV{'form.show_errors'} eq 'on'));
 1407: }
 1408: 
 1409: sub error {
 1410:     $errorcount++;
 1411:     if ( &show_error_warn_msg() ) {
 1412: 	# If printing in construction space, put the error inside <pre></pre>
 1413: 	push(@Apache::lonxml::error_messages,
 1414: 	     $Apache::lonxml::warnings_error_header.
 1415: 	     "<b>ERROR:</b>".join("<br />\n",@_)."<br />\n");
 1416: 	$Apache::lonxml::warnings_error_header='';
 1417:     } else {
 1418: 	my $errormsg;
 1419: 	my ($symb)=&Apache::lonnet::symbread();
 1420: 	if ( !$symb ) {
 1421: 	    #public or browsers
 1422: 	    $errormsg=&mt("An error occured while processing this resource. The author has been notified.");
 1423: 	} 
 1424: 	#notify author
 1425: 	&Apache::lonmsg::author_res_msg($ENV{'request.filename'},join('<br />',@_));
 1426: 	#notify course
 1427: 	if ( $symb && $ENV{'request.course.id'} ) {
 1428: 	    my (undef,%users)=&Apache::lonfeedback::decide_receiver(undef,0,1,1,1);
 1429: 	    my $declutter=&Apache::lonnet::declutter($ENV{'request.filename'});
 1430: 	    my @userlist;
 1431: 	    foreach (keys %users) {
 1432: 		my ($user,$domain) = split(/:/, $_);
 1433: 		push(@userlist,"$user\@$domain");
 1434: 		&Apache::lonmsg::user_normal_msg($user,$domain,
 1435: 						 "Error [$declutter]",join('<br />',@_));
 1436: 	    }
 1437: 	    if ($ENV{'request.role.adv'}) {
 1438: 		$errormsg=&mt("An error occured while processing this resource. The course personnel ([_1]) and the author have been notified.",join(', ',@userlist));
 1439: 	    } else {
 1440: 		$errormsg=&mt("An error occured while processing this resource. The instructor has been notified.");
 1441: 	    }
 1442: 	}
 1443: 	push(@Apache::lonxml::error_messages,"<b>$errormsg</b> <br />");
 1444:     }
 1445: }
 1446: 
 1447: sub warning {
 1448:     $warningcount++;
 1449:   
 1450:     if ($ENV{'form.grade_target'} ne 'tex') {
 1451: 	if ( &show_error_warn_msg() ) {
 1452: 	    my $request=$Apache::lonxml::request;
 1453: 	    if (!$request) { $request=Apache->request; }
 1454: 	    push(@Apache::lonxml::warning_messages,
 1455: 		 $Apache::lonxml::warnings_error_header.
 1456: 		 "<b>W</b>ARNING<b>:</b>".join('<br />',@_)."<br />\n");
 1457: 	    $Apache::lonxml::warnings_error_header='';
 1458: 	}
 1459:     }
 1460: }
 1461: 
 1462: sub info {
 1463:     if ($ENV{'form.grade_target'} ne 'tex' 
 1464: 	&& $ENV{'request.state'} eq 'construct') {
 1465: 	push(@Apache::lonxml::info_messages,join('<br />',@_)."<br />\n");
 1466:     }
 1467: }
 1468: 
 1469: sub message_location {
 1470:     return '__LONCAPA_INTERNAL_MESSAGE_LOCATION__';
 1471: }
 1472: 
 1473: sub add_messages {
 1474:     my ($msg)=@_;
 1475:     my $result=join(' ',
 1476: 		    @Apache::lonxml::info_messages,
 1477: 		    @Apache::lonxml::error_messages,
 1478: 		    @Apache::lonxml::warning_messages);
 1479:     undef(@Apache::lonxml::info_messages);
 1480:     undef(@Apache::lonxml::error_messages);
 1481:     undef(@Apache::lonxml::warning_messages);
 1482:     $$msg=~s/__LONCAPA_INTERNAL_MESSAGE_LOCATION__/$result/;
 1483:     $$msg=~s/__LONCAPA_INTERNAL_MESSAGE_LOCATION__//g;
 1484: }
 1485: 
 1486: sub get_param {
 1487:     my ($param,$parstack,$safeeval,$context,$case_insensitive) = @_;
 1488:     if ( ! $context ) { $context = -1; }
 1489:     my $args ='';
 1490:     if ( $#$parstack > (-2-$context) ) { $args=$$parstack[$context]; }
 1491:     if ( ! $Apache::lonxml::usestyle ) {
 1492: 	$args=$Apache::lonxml::style_values.$args;
 1493:     }
 1494:     if ( ! $args ) { return undef; }
 1495:     if ( $case_insensitive ) {
 1496: 	if ($args =~ s/(my \$)(\Q$param\E)(=\")/$1.lc($2).$3/ei) {
 1497: 	    return &Apache::run::run("{$args;".'return $'.$param.'}',
 1498:                                      $safeeval); #'
 1499: 	} else {
 1500: 	    return undef;
 1501: 	}
 1502:     } else {
 1503: 	if ( $args =~ /my \$\Q$param\E=\"/ ) {
 1504: 	    return &Apache::run::run("{$args;".'return $'.$param.'}',
 1505:                                      $safeeval); #'
 1506: 	} else {
 1507: 	    return undef;
 1508: 	}
 1509:     }
 1510: }
 1511: 
 1512: sub get_param_var {
 1513:   my ($param,$parstack,$safeeval,$context,$case_insensitive) = @_;
 1514:   if ( ! $context ) { $context = -1; }
 1515:   my $args ='';
 1516:   if ( $#$parstack > (-2-$context) ) { $args=$$parstack[$context]; }
 1517:   if ( ! $Apache::lonxml::usestyle ) {
 1518:       $args=$Apache::lonxml::style_values.$args;
 1519:   }
 1520:   &Apache::lonxml::debug("Args are $args param is $param");
 1521:   if ($case_insensitive) {
 1522:       if (! ($args=~s/(my \$)(\Q$param\E)(=\")/$1.lc($2).$3/ei)) {
 1523: 	  return undef;
 1524:       }
 1525:   } elsif ( $args !~ /my \$\Q$param\E=\"/ ) { return undef; }
 1526:   my $value=&Apache::run::run("{$args;".'return $'.$param.'}',$safeeval); #'
 1527:   &Apache::lonxml::debug("first run is $value");
 1528:   if ($value =~ /^[\$\@\%][a-zA-Z_]\w*$/) {
 1529:       &Apache::lonxml::debug("doing second");
 1530:       my @result=&Apache::run::run("return $value",$safeeval,1);
 1531:       if (!defined($result[0])) {
 1532: 	  return $value
 1533:       } else {
 1534: 	  if (wantarray) { return @result; } else { return $result[0]; }
 1535:       }
 1536:   } else {
 1537:     return $value;
 1538:   }
 1539: }
 1540: 
 1541: sub register_insert {
 1542:   my @data = split /\n/, &Apache::lonnet::getfile('/home/httpd/lonTabs/insertlist.tab');
 1543:   my $i;
 1544:   my $tagnum=0;
 1545:   my @order;
 1546:   for ($i=0;$i < $#data; $i++) {
 1547:     my $line = $data[$i];
 1548:     if ( $line =~ /^\#/ || $line =~ /^\s*\n/) { next; }
 1549:     if ( $line =~ /TABLE/ ) { last; }
 1550:     my ($tag,$descrip,$color,$function,$show,$helpfile,$helpdesc) = split(/,/, $line);
 1551:     if ($tag) {
 1552:       $insertlist{"$tagnum.tag"} = $tag;
 1553:       $insertlist{"$tagnum.description"} = $descrip;
 1554:       $insertlist{"$tagnum.color"} = $color;
 1555:       $insertlist{"$tagnum.function"} = $function;
 1556:       if (!defined($show)) { $show='yes'; }
 1557:       $insertlist{"$tagnum.show"}= $show;
 1558:       $insertlist{"$tagnum.helpfile"} = $helpfile;
 1559:       $insertlist{"$tagnum.helpdesc"} = $helpdesc;
 1560:       $insertlist{"$tag.num"}=$tagnum;
 1561:       $tagnum++;
 1562:     }
 1563:   }
 1564:   $i++; #skipping TABLE line
 1565:   $tagnum = 0;
 1566:   for (;$i < $#data;$i++) {
 1567:     my $line = $data[$i];
 1568:     my ($mnemonic,@which) = split(/ +/,$line);
 1569:     my $tag = $insertlist{"$tagnum.tag"};
 1570:     for (my $j=0;$j <=$#which;$j++) {
 1571:       if ( $which[$j] eq 'Y' ) {
 1572: 	if ($insertlist{"$j.show"} ne 'no') {
 1573: 	  push(@{ $insertlist{"$tag.which"} },$j);
 1574: 	}
 1575:       }
 1576:     }
 1577:     $tagnum++;
 1578:   }
 1579: }
 1580: 
 1581: sub description {
 1582:   my ($token)=@_;
 1583:   my $tagnum;
 1584:   my $tag=$token->[1];
 1585:   foreach my $namespace (reverse @Apache::lonxml::namespace) {
 1586:     my $testtag=$namespace.'::'.$tag;
 1587:     $tagnum=$insertlist{"$testtag.num"};
 1588:     if (defined($tagnum)) { last; }
 1589:   }
 1590:   if (!defined ($tagnum)) { $tagnum=$Apache::lonxml::insertlist{"$tag.num"}; }
 1591:   return $insertlist{$tagnum.'.description'};
 1592: }
 1593: 
 1594: # Returns a list containing the help file, and the description
 1595: sub helpinfo {
 1596:   my ($token)=@_;
 1597:   my $tagnum;
 1598:   my $tag=$token->[1];
 1599:   foreach my $namespace (reverse @Apache::lonxml::namespace) {
 1600:     my $testtag=$namespace.'::'.$tag;
 1601:     $tagnum=$insertlist{"$testtag.num"};
 1602:     if (defined($tagnum)) { last; }
 1603:   }
 1604:   if (!defined ($tagnum)) { $tagnum=$Apache::lonxml::insertlist{"$tag.num"}; }
 1605:   return ($insertlist{$tagnum.'.helpfile'}, $insertlist{$tagnum.'.helpdesc'});
 1606: }
 1607: 
 1608: # ----------------------------------------------------------------- whichuser
 1609: # returns a list of $symb, $courseid, $domain, $name that is correct for
 1610: # calls to lonnet functions for this setup.
 1611: # - looks for form.grade_ parameters
 1612: sub whichuser {
 1613:   my ($passedsymb)=@_;
 1614:   my ($symb,$courseid,$domain,$name,$publicuser);
 1615:   if (defined($ENV{'form.grade_symb'})) {
 1616:       my ($tmp_courseid)=
 1617: 	  &Apache::loncommon::get_env_multiple('form.grade_courseid');
 1618:       my $allowed=&Apache::lonnet::allowed('vgr',$tmp_courseid);
 1619:       if (!$allowed && 
 1620: 	  exists($ENV{'request.course.sec'}) && 
 1621: 	  $ENV{'request.course.sec'} !~ /^\s*$/) {
 1622: 	  $allowed=&Apache::lonnet::allowed('vgr',$tmp_courseid.
 1623: 					    '/'.$ENV{'request.course.sec'});
 1624:       }
 1625:       if ($allowed) {
 1626: 	  ($symb)=&Apache::loncommon::get_env_multiple('form.grade_symb');
 1627: 	  $courseid=$tmp_courseid;
 1628: 	  ($domain)=&Apache::loncommon::get_env_multiple('form.grade_domain');
 1629: 	  ($name)=&Apache::loncommon::get_env_multiple('form.grade_username');
 1630: 	  return ($symb,$courseid,$domain,$name,$publicuser);
 1631:       }
 1632:   }
 1633:   if (!$passedsymb) {
 1634:       $symb=&Apache::lonnet::symbread();
 1635:   } else {
 1636:       $symb=$passedsymb;
 1637:   }
 1638:   $courseid=$ENV{'request.course.id'};
 1639:   $domain=$ENV{'user.domain'};
 1640:   $name=$ENV{'user.name'};
 1641:   if ($name eq 'public' && $domain eq 'public') {
 1642:       if (!defined($ENV{'form.username'})) {
 1643: 	  $ENV{'form.username'}.=time.rand(10000000);
 1644:       }
 1645:       $name.=$ENV{'form.username'};
 1646:   }
 1647:   return ($symb,$courseid,$domain,$name,$publicuser);
 1648: }
 1649: 
 1650: 1;
 1651: __END__
 1652: 
 1653: 

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