[BACK]Return to lontexconvert.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / xml

Diff for /loncom/xml/lontexconvert.pm between versions 1.14 and 1.48

version 1.14, 2003/02/03 18:03:53 version 1.48, 2005/02/24 05:40:08
Line 36 Line 36
 # The C source of the Code may not be distributed by the Licensee  # The C source of the Code may not be distributed by the Licensee
 # to any other parties under any circumstances.  # to any other parties under any circumstances.
 #  #
 # 05/29/00,05/30,10/11,10/20 Gerd Kortemeyer  
 # 5/4 Gerd Kortemeyer  
   
 package Apache::lontexconvert;  package Apache::lontexconvert;
   
 use strict;  use strict;
 use tth;  use tth();
 use vars qw($errorstring);  use vars qw($errorstring);
 use Apache::lonmsg;  use Apache();
 use Apache::lonxml;  use Apache::lonmsg();
   use Apache::lonxml();
   use Apache::lonmenu();
   use Apache::lonlocal;
   
 # ====================================================================== Header  # ====================================================================== Header
   
   sub init_tth {
       my $options=$ENV{'course.'.$ENV{'request.course.id'}.'.tthoptions'};
       if ($ENV{'browser.mathml'}) {
    &tth::ttminit();
    if ($ENV{'browser.unicode'}) {
       &tth::ttmoptions('-L -u1 '.$options);
    } else {
       &tth::ttmoptions('-L -u0 '.$options);
    }
       } else {
    &tth::tthinit();
    if ($ENV{'browser.unicode'}) {
       &tth::tthoptions('-L -u1 '.$options);
    } else {
       &tth::tthoptions('-L -u0 '.$options);
    }
       }
   }
   
 sub header {  sub header {
   $errorstring='';      $errorstring='';
   my $time=time;      my $time=time;
   if ($ENV{'browser.mathml'}) {      &init_tth();
       &tth::ttminit();      return &Apache::lonxml::xmlbegin().
       if ($ENV{'browser.unicode'}) {   "\n<head>\n".
   &tth::ttmoptions('-L -u1');   &Apache::lonxml::fontsettings().
       } else {   &Apache::lonmenu::registerurl(undef,'tex').
   &tth::ttmoptions('-L -u0');   "\n</head>\n";
       }  
   } else {  
       &tth::tthinit();  
       if ($ENV{'browser.unicode'}) {  
   &tth::tthoptions('-L -u1');  
       } else {  
   &tth::tthoptions('-L -u0');  
       }  
   }  
   return &Apache::lonxml::xmlbegin().  
          &Apache::lonxml::fontsettings().  
          "\n<head>\n".  
          &Apache::lonxml::registerurl(undef,'tex').  
  "\n</head>\n";  
 }  }
   
 # ================================================================== Conversion  # ================================================================== Conversion
   
 sub converted {  $Apache::lontexconvert::messedup=0;
   my $texstring=shift;  
   my $xmlstring='[UNDISPLAYABLE]';  # we need this routine because &converted can get called from inside
   eval(<<'ENDCONV');  # of the safespace (through &xmlparse('<m>stuff</m>') which doesn't
   {   # allow the opcode for alarm, so we need to compile this before we get
     local $SIG{SEGV}=sub { die; };  # into the safe space since opcode checks only occur at compile time
   sub convert_real {
       my ($texstring)=@_;
       my ($xmlstring,$errorstring);
       local $SIG{SEGV}=sub { $Apache::lontexconvert::messedup=1; die; };
       local $SIG{ALRM}=sub { 
    &Apache::lonnet::logthis("ALRM");
    $xmlstring='['.&mt("TeX unconverted due to errors").']';
    $Apache::lontexconvert::messedup=1;
    die &mt("TeX unconverted due to errors");
       };
       alarm($Apache::lonnet::perlvar{'lonScriptTimeout'});
     if ($ENV{'browser.mathml'}) {      if ($ENV{'browser.mathml'}) {
       $xmlstring=&tth::ttm($$texstring);   $xmlstring=&tth::ttm($$texstring);
       $xmlstring=~s/\<math\>/\<math xmlns=\"\&mathns\;\"\>/g;   $xmlstring=~s/\<math\>/\<math xmlns=\"\&mathns\;\"\>/g;
       $xmlstring=~s/\<br\>/\<br\/\>/g;   $xmlstring=~s/\<br\>/\<br\/\>/g;
       $xmlstring=~s/\<p\>/\<p\>\<\/p\>/g;   $xmlstring=~s/\<p\>/\<p\>\<\/p\>/g;
       $errorstring.=&tth::ttmerror();   $errorstring.=&tth::ttmerror();
     } else {      } else {
       $xmlstring=&tth::tth($$texstring);   $xmlstring=&tth::tth($$texstring);
       $errorstring.=&tth::ttherror();   $errorstring.=&tth::ttherror();
    $xmlstring=~s-</font(\s*)>-</font>-g;
     }      }
   }      $xmlstring=~s/^\s*\<br clear\=\"all\"/\<br/s;
       $xmlstring=~s/^\s*//;
       $xmlstring=~s/\s*$//;
       alarm(0);
       return ($xmlstring,$errorstring);
   }
   
   sub converted {
       my $texstring=shift;
       my $xmlstring='['.&mt('UNDISPLAYABLE').']';
       if ($Apache::lontexconvert::messedup) {
    return '['.&mt('TeX unconverted due to previous errors').']';
       }
       eval(<<'ENDCONV');
       ($xmlstring,$errorstring)=&convert_real($texstring)
 ENDCONV  ENDCONV
   return $xmlstring;      if ($@) {
    $errorstring.=&mt("Evaluation Error: ").$@;
    $Apache::lontexconvert::messedup=1;
       }
       if ($Apache::lontexconvert::messedup || &tth::tthmessedup() || 
    $errorstring) {
    &Apache::lonnet::logthis("Trying to kill myself");
    $Apache::lontexconvert::messedup=1;
    my $request=Apache->request();
    $request->child_terminate();
       }
       return $xmlstring;
 }  }
   
 # ====================================================================== Footer  # ====================================================================== Footer
Line 115  sub footer { Line 158  sub footer {
   
 sub to_convert {  sub to_convert {
     my ($string) = @_;      my ($string) = @_;
     $string=~s/\<br\s*\/?\>/ /g;      $string=~s/\<br\s*\/?\>/ /gs;
   #    $string=~s/\s/ /gs;
       $string=&HTML::Entities::decode($string);
     return &converted(\$string);      return &converted(\$string);
 }  }
   
   sub smiley {
       my $expression=shift;
       if ($ENV{'browser.imagesuppress'} eq 'on') { return $expression; }
       my %smileys=('\:\-\)' => 'smiley',
    '8\-\)'  => 'coolsmile',
    '8\-(I|\|)'   => 'coolindiff',
    ':\-(I|\|)'   => 'neutral',
    '\:\-(o|O|\(\))' => 'shocked',
    ':\-\('  => 'frowny',
    '\;\-\)' => 'wink',
    '\:\-P'  => 'baeh',
    '\:\-(\\\|\\/)' => 'hrrm',
    '\:\-D'  => 'bigsmile',
    '\:\-C'  => 'angry',
    '\:(\'|\`)\-\(' => 'cry',
    '\:\-(X|\#)' => 'lipsrsealed',
    '\:\-S' => 'huh');
       my $iconpath=$Apache::lonnet::perlvar{'lonIconsURL'};
       foreach (keys %smileys) {
    $expression=~s/$_/\<img src="$iconpath\/$smileys{$_}.gif" \/\>/gs; 
       }
       return $expression;
   }
   
 sub msgtexconverted {  sub msgtexconverted {
     my $message=shift;      my ($message,$email) = @_;
       $errorstring='';
       &init_tth();
       my $outmessage='';
       my $tex=0;
       foreach (split(/(?:\&lt\;|\<)\/*m\s*(?:\&gt\;|\>)/i,$message)) {
    if ($tex) {
       if ($email) {
    $outmessage.='</pre><tt>'.&to_convert($_).'</tt><pre>'; $tex=0;
       } else {
    $outmessage.=&to_convert($_); $tex=0;
       }
    } else {
               $outmessage.=&smiley($_); $tex=1;
    }
       }
       if (wantarray) {
    return ($outmessage,$errorstring);
       } else {
    return $outmessage.$errorstring;
       }
   }
   
     #FIXME this crap needs to go but right now the -L option might be  sub algebra {
     #ignored if this isn;t the first time the tth engine is used      my ($string,$target)=@_;
     #thus the \\document class crap, it makes sure we init the LaTeX stuff      my $parser = new AlgParserWithImplicitExpand;
     if ($ENV{'browser.mathml'}) {      $string=&prepare_algebra($string);
       &tth::ttminit();      my $ret = $parser->parse($string);
       &tth::ttmoptions("-L");      my $result='['.&mt('Algebra unconverted due to previous errors').']';
       if ( ref($ret) ) {
    $parser->tostring();
    $parser->normalize();
    my $latex=$parser->tolatex();
    $latex=&postprocess_algebra($string);
    $latex='$'.$latex.'$';
    if ($target eq 'web' || $target eq 'analyze') {
       $result = &converted(\$latex);
    } else {
       $result = $latex;
    }
     } else {      } else {
       &tth::tthinit();   &Apache::lonxml::error($parser->{'htmlerror'});
       &tth::tthoptions("-L");  
     }      }
     $message=~s/(\$\$.+?\$\$)/&to_convert("\\documentclass{article}".$1)/ge;  
     $message=~s/(\$.+?\$)/&to_convert("\\documentclass{article}".$1)/ge;  
     $message=~s/(\\\(.+?\\\))/&to_convert("\\documentclass{article}".$1)/ge;  
     $message=~s/(\\\[.+?\\\])/&to_convert("\\documentclass{article}".$1)/ge;  
     return $message.$errorstring;  
 }  }
   
   sub prepare_algebra {
       my ($string)=@_;
   
       # change some multi character operators into single character operators
       $string =~ s/<>/\#/g;
       $string =~ s/<\=/\%/g;
       $string =~ s/>\=/\!/g;
       
       # makes the decision about what is a minus sign easier
       $string =~ s/([\=\>\<\%\!\#] *)-/$1 zeroplace -/g;
   
       # protect the confusable greek symbols
       $string =~ s/delta/zdelta/g;
       $string =~ s/beta/bita/g;
       $string =~ s/theta/thita/g;
       $string =~ s/zeta/zita/g;
       $string =~ s/eta/xeta/g;
       $string =~ s/epsilon/zepslon/g;
       $string =~ s/upsilon/zupslon/g;
     
       return $string;
   }
   
   sub postprocess_algebra {
       my ($string)=@_;
       
       # remove the chunk used to sepearate out the minus signs
       $string =~ s/zeroplace//g;
   
       # exapnd out some operators
       $string =~ s/\#/\\not= /g;
       $string =~ s/\%/\\leq /g;
       $string =~ s/\!/\\geq /g;
   
       # replace some special symbols with the LaTeX equivalents
       $string =~ s/infty/\\infty/g;
       $string =~ s/infinity/\\infty/g;
       $string =~ s/alpha/\\alpha/g;  
       $string =~ s/gamma/\\gamma/g; 
       $string =~ s/iota/\\iota/g;
       $string =~ s/kappa/\\kappa/g;
       $string =~ s/lambda/\\lambda/g;
       $string =~ s/mu/\\mu/g;
       $string =~ s/nu/\\nu/g;
       $string =~ s/xi/\\xi/g;
       $string =~ s/rho/\\rho/g;
       $string =~ s/sigma/\\sigma/g;
       $string =~ s/tau/\\tau/g;
       $string =~ s/phi/\\phi/g;
       $string =~ s/chi/\\chi/g;
       $string =~ s/psi/\\psi/g;
       $string =~ s/omega/\\omega/g;
       $string =~ s/zdelta/\\delta/g;
       $string =~ s/bita/\\beta/g;
       $string =~ s/thita/\\theta/g;
       $string =~ s/zita/\\zeta/g;
       $string =~ s/xeta/\\eta/g;
       $string =~ s/zepslon/\\epsilon/g;
       $string =~ s/zupslon/\\upsilon/g;
   
       return $string;
   }
 1;  1;
 __END__  __END__
   
Removed from v.1.14  
changed lines
  Added in v.1.48

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