source/texlabelmanager.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include "texlabelmanager.h"
  20 #include "dynamicenvironment.h"
  21 #include "simplepdfo.h"
  22 #include "simplepdfi.h"
  23 #include "shapesexceptions.h"
  24 #include "globals.h"
  25 #include "texscanner.h"
  26
  27 #include <fstream>
  28 #include <sstream>
  29 #include <iomanip>
  30 #include <algorithm>
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <sys/wait.h>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <ctype.h>
  39
  40 using namespace std;
  41 using namespace Shapes;
  42
  43 namespace Shapes
  44 {
  45         namespace Interaction
  46         {
  47                 void systemDebugMessage( const std::string & msg );
  48         }
  49 }
  50
  51
  52 Kernel::TeXLabelManager::TeXLabelManager( )
  53         : anyLabelMiss( false ), loadCount( 0 ), jobNumber( 0 ), documentclass( "article" ), lmodernT1( true ), utf8( true ), setupFinalized( false )
  54 { }
  55
  56
  57 Kernel::TeXLabelManager::~TeXLabelManager( )
  58 { }
  59
  60
  61 std::string
  62 Kernel::TeXLabelManager::stringWithJobNumber( const std::string & str, bool withDirectory ) const
  63 {
  64         ostringstream res;
  65         if( withDirectory )
  66                 {
  67                         res << tmpDir_ ;
  68                 }
  69         res << str ;
  70         if( jobNumber >= 0 )
  71                 {
  72                         res << jobNumber ;
  73                 }
  74         return res.str( );
  75 }
  76
  77
  78 void
  79 Kernel::TeXLabelManager::setup( const std::string & inDir, const std::string & tmpDir, const std::string & texJobName )
  80 {
  81         inDir_ = inDir;
  82         tmpDir_ = tmpDir;
  83         texJobName_ = texJobName;
  84 }
  85
  86
  87 void
  88 Kernel::TeXLabelManager::announce( const std::string & str, const Ast::SourceLocation & loc )
  89 {
  90         if( isAllBlank( str.c_str( ) ) )
  91                 {
  92                         return;
  93                 }
  94
  95         if( availableLabels.find( safeSourceHash( str ) ) == availableLabels.end( ) )
  96                 {
  97                         typedef typeof currentRequests RequestMapType;
  98                         currentRequests.insert( RequestMapType::value_type( str, RequestLocation( true, loc ) ) );
  99                 }
 100 }
 101
 102
 103 RefCountPtr< const Lang::Value >
 104 Kernel::TeXLabelManager::request( const std::string & str, const Ast::SourceLocation & loc, Kernel::PassedDyn dyn )
 105 {
 106         if( isAllBlank( str.c_str( ) ) )
 107                 {
 108                         return static_cast< RefCountPtr< const Lang::Geometric2D > >( Lang::THE_POINTPICTURE );
 109                 }
 110
 111         allRequests.insert( str );
 112         string hash = safeSourceHash( str );
 113         MapType::iterator i = availableLabels.find( hash );
 114         if( i == availableLabels.end( ) )
 115                 {
 116                         ++jobNumber;
 117                         anyLabelMiss = true;
 118                         typedef typeof currentRequests RequestMapType;
 119                         currentRequests.insert( RequestMapType::value_type( str, RequestLocation( false, loc ) ) );
 120                         processRequests( );
 121                         string extendedName = stringWithJobNumber( texJobName_ ) + ".pdf";
 122                         RefCountPtr< ifstream > iFile = RefCountPtr< ifstream >( new ifstream( extendedName.c_str( ) ) );
 123                         if( ! iFile->good( ) )
 124                                 {
 125                                         throw Exceptions::InternalError( strrefdup( "Failed to open " + extendedName + " for input." ) );
 126                                 }
 127                         loadLabels( iFile );
 128                         i = availableLabels.find( hash );
 129                 }
 130         if( i == availableLabels.end( ) )
 131                 {
 132                         throw Exceptions::InternalError( strrefdup( "Failed to find generated label: " + str ) );
 133                 }
 134         return static_cast< RefCountPtr< const Lang::Geometric2D > >( i->second->cloneWithState( dyn->getGraphicsState( ), dyn->getTeXBleed( ) ) );
 135 }
 136
 137 namespace Shapes
 138 {
 139         namespace Kernel
 140         {
 141                 typedef std::pair< std::string, Kernel::TeXLabelManager::RequestLocation > T;
 142                 class RequestsOrder : public std::binary_function< T, T, bool >
 143                 {
 144                 public:
 145                         result_type operator () ( const first_argument_type & x1, const second_argument_type & x2 )
 146                         {
 147                                 return x1.first < x2.first;
 148                         }
 149                 };
 150         }
 151 }
 152
 153 void
 154 Kernel::TeXLabelManager::iterativeStartup( RefCountPtr< std::istream > labelsFile )
 155 {
 156         try
 157                 {
 158                         loadLabels( labelsFile );
 159
 160                         /* Remove the labels already generated from the request set.
 161                                  Since the available set is hashed, one must search the request set for elements in the available set, rather than vice versa.
 162                                  Process in two steps:  1) find the intersection 2) remove it.
 163                         */
 164                         typedef typeof currentRequests T;
 165                         T removeSet;
 166                         for( T::iterator i = currentRequests.begin( ); i != currentRequests.end( ); ++i )
 167                                 {
 168                                         if( availableLabels.find( safeSourceHash( i->first ) ) != availableLabels.end( ) )
 169                                                 {
 170                                                         removeSet.insert( *i );
 171                                                 }
 172                                 }
 173                         T tmp;
 174                         set_difference( currentRequests.begin( ), currentRequests.end( ),
 175                                                                                         removeSet.begin( ), removeSet.end( ),
 176                                                                                         insert_iterator< T >( tmp, tmp.begin( ) ),
 177                                                                                         Kernel::RequestsOrder( ) );
 178                         currentRequests = tmp;
 179                 }
 180         catch( const Exceptions::TeXSetupHasChanged & ball )
 181                 {
 182                         /* never mind */
 183                 }
 184 }
 185
 186
 187 void
 188 Kernel::TeXLabelManager::iterativeFinish( const std::string & labelDBFilename )
 189 {
 190         if( ! anyLabelMiss )
 191                 {
 192                         return;
 193                 }
 194         if( loadCount == 1 )
 195                 {
 196                         if( jobNumber == 0 )
 197                                 {
 198                                         // We have only used old labels.
 199                                         return;
 200                                 }
 201                         // Otherwise, the only generated pdf file with labels is a good database.
 202
 203                         string lastJobFilename = stringWithJobNumber( texJobName_ ) + ".pdf";
 204
 205                         {
 206                                 ostringstream mvCommand;
 207                                 {
 208                                         // Avoid invoking the mv command if the file does not exist.
 209                                         struct stat theStat;
 210                                         if( stat( lastJobFilename.c_str( ), & theStat ) != 0 )
 211                                                 {
 212                                                         return;
 213                                                 }
 214                                 }
 215
 216                                 if( lastJobFilename == labelDBFilename )
 217                                         {
 218                                                 // Move would yield a warning since we're not really moving anything.
 219                                                 return;
 220                                         }
 221
 222                                 mvCommand << "mv '" << lastJobFilename << "' '" << labelDBFilename << "'";
 223                                 Interaction::systemDebugMessage( mvCommand.str( ) );
 224                                 if( system( mvCommand.str( ).c_str( ) ) != 0 )
 225                                         {
 226                                                 // Never mind
 227                                         }
 228                         }
 229                         return;
 230                 }
 231
 232         for( std::set< std::string >::const_iterator i = allRequests.begin( );
 233                          i != allRequests.end( );
 234                          ++i )
 235                 {
 236                         typedef typeof currentRequests RequestMapType;
 237                         currentRequests.insert( RequestMapType::value_type( *i, RequestLocation( true, Ast::THE_UNKNOWN_LOCATION ) ) );
 238                 }
 239         jobNumber = -1;
 240         processRequests( );
 241
 242         {
 243                 string finalJobFilename = stringWithJobNumber( texJobName_ ) + ".pdf";
 244                 ostringstream mvCommand;
 245                 {
 246                         // Avoid invoking the mv command if the file does not exist.
 247                         struct stat theStat;
 248                         if( stat( finalJobFilename.c_str( ), & theStat ) != 0 )
 249                                 {
 250                                         return;
 251                                 }
 252                 }
 253
 254                 if( finalJobFilename == labelDBFilename )
 255                         {
 256                                 // Move would yield a warning since we're not really moving anything.
 257                                 return;
 258                         }
 259
 260                 mvCommand << "mv '" << finalJobFilename << "' '" << labelDBFilename << "'";
 261                 Interaction::systemDebugMessage( mvCommand.str( ) );
 262                 if( system( mvCommand.str( ).c_str( ) ) != 0 )
 263                         {
 264                                 // Never mind
 265                         }
 266         }
 267 }
 268
 269 namespace Shapes
 270 {
 271         namespace Kernel
 272         {
 273                 template< class T >
 274                 class ClearOnExit
 275                 {
 276                         T * container_;
 277                 public:
 278                         ClearOnExit( T * container )
 279                                 : container_( container )
 280                         {       }
 281                         ~ClearOnExit( )
 282                         {
 283                                 container_->clear( );
 284                         }
 285                 };
 286         }
 287 }
 288
 289 void
 290 Kernel::TeXLabelManager::processRequests( )
 291 {
 292         string extendedName = stringWithJobNumber( texJobName_ ) + ".tex";
 293         ofstream texFile( extendedName.c_str( ) );
 294         if( ! texFile.good( ) )
 295                 {
 296                         throw Exceptions::FileWriteOpenError( Ast::THE_UNKNOWN_LOCATION, strrefdup( extendedName ), "(TeX source)" );
 297                 }
 298
 299         if( ! setupFinalized )
 300                 {
 301                         compileSetupCode( );
 302                 }
 303
 304         texFile << setupCode ;
 305         texFile << "\\btexetexthing{" << "Shapes setup info" << "}{" << safeSourceHash( setupCode ) << "}{-1}" << endl ;
 306
 307         {
 308                 size_t labelIndex = 0;
 309                 typedef typeof currentRequests RequestMapType;
 310                 for( RequestMapType::const_iterator i = currentRequests.begin( );
 311                                  i != currentRequests.end( );
 312                                  ++i, ++labelIndex )
 313                         {
 314                                 assertBalanced( i->first, i->second );
 315                                 texFile << "\\btexetexthing{" << i->first << "}{" << safeSourceHash( i->first ) << "}{" << labelIndex << "}" << endl ;
 316                         }
 317         }
 318         ClearOnExit< typeof currentRequests > autoClear( & currentRequests );
 319
 320         texFile << "\\end{document}" << endl ;
 321
 322         pid_t latexProcess = fork( );
 323         if( latexProcess == -1 )
 324                 {
 325                         throw Exceptions::InternalError( strrefdup( "Failed to fork a process for running LaTeX." ) );
 326                 }
 327
 328         if( latexProcess == 0 ) /* This is the child */
 329                 {
 330                         /* The exec call below never returns, so the child process never leaves this if clause.
 331                          * Hence, there is no need to create a special else clasuse below.
 332                          */
 333                         Interaction::systemDebugMessage( "cd " + inDir_ );
 334                         if( chdir( inDir_.c_str( ) ) != 0 )
 335                                 {
 336                                         switch( errno )
 337                                                 {
 338                                                 case ENOENT:
 339                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in the no-entry failure." ) );
 340                                                 case ENOTDIR:
 341                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in the not-a-directory failure." ) );
 342                                                 case EACCES:
 343                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in the no-search-permission failure." ) );
 344                                                 case ELOOP:
 345                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in the symbolic-link-loop failure." ) );
 346                                                 case EIO:
 347                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in the I/O failure." ) );
 348                                                 default:
 349                                                         throw Exceptions::InternalError( strrefdup( "Attempt to change to source directory resulted in an unclassified failure." ) );
 350                                                 }
 351                                 }
 352                         string extendedName = stringWithJobNumber( texJobName_ );
 353                         if( Interaction::pdfLaTeXInteractionTo_stderr )
 354                                 {
 355                                         dup2( 2, 1 );
 356                                 }
 357                         else
 358                                 {
 359                                         std::string stdout_filename = extendedName + ".stdout";
 360                                         int stdout_file = open( stdout_filename.c_str( ), O_WRONLY | O_CREAT,
 361                                                                                                                                         S_IRUSR | S_IWUSR );
 362                                         if( stdout_file == -1 )
 363                                                 {
 364                                                         throw Exceptions::FileWriteOpenError( Ast::THE_UNKNOWN_LOCATION, strrefdup( stdout_filename ), "(destination for stdout from pdfLaTeX)"  );
 365                                                 }
 366                                         dup2( stdout_file, 1 );
 367                                         close( stdout_file );
 368                                 }
 369                         execlp( "pdflatex", "pdflatex", "-output-directory", tmpDir_.c_str( ), "-interaction", "nonstopmode", extendedName.c_str( ), static_cast< const char * >( 0 ) );
 370                         if( errno != 0 )
 371                                 {
 372                                         ostringstream oss;
 373                                         oss << "Recieved errno = " << errno << " from execlp call to pdfLaTeX." ;
 374                                         throw Exceptions::InternalError( strrefdup( oss ) );
 375                                 }
 376                         throw Exceptions::InternalError( strrefdup( "execlp call to pdfLaTeX returned with errno == 0." ) );
 377                 }
 378
 379         while( true )
 380                 {
 381                         int status;
 382                         pid_t wpid = waitpid( latexProcess, & status, 0 );
 383                         if( wpid == 0 )
 384                                 {
 385                                         continue;
 386                                 }
 387                         if( wpid == -1 )
 388                                 {
 389                                         if( errno == EINTR )
 390                                                 {
 391                                                         throw Exceptions::InternalError( strrefdup( "Signal recieved while waiting for pdfLaTeX process." ) );
 392                                                 }
 393                                         else
 394                                                 {
 395                                                         throw Exceptions::InternalError( strrefdup( "waitpid failure when waiting for pdfLaTeX process." ) );
 396                                                 }
 397                                 }
 398
 399                         if( WIFEXITED( status ) )
 400                                 {
 401                                         if( WEXITSTATUS( status ) != 0 )
 402                                                 {
 403                                                         if( Interaction::pdfLaTeXInteractionTo_stderr )
 404                                                                 {
 405                                                                         throw Exceptions::TeXLabelError( false, "(--tex-debug)", strrefdup( "The output from pdfLaTeX was written to stderr." ), RefCountPtr< const char >( NullPtr< const char >( ) ), Ast::THE_UNKNOWN_LOCATION );
 406                                                                 }
 407
 408                                                         std::string stdoutFilename = stringWithJobNumber( texJobName_ ) + ".stdout";
 409                                                         std::ifstream stdoutFile( stdoutFilename.c_str( ) );
 410                                                         if( ! stdoutFile.good( ) )
 411                                                                 {
 412                                                                         throw Exceptions::InternalError( strrefdup( "Failed to open the file where pdfLaTeX's output to stdout should have been saved: " + stdoutFilename ) );
 413                                                                 }
 414                                                         parseTeXErrors( stdoutFile );
 415                                                 }
 416                                         break;
 417                                 }
 418                         else if( WIFSIGNALED( status ) )
 419                                 {
 420                                         ostringstream oss;
 421                                         oss << "pdfLaTeX was killed by the signal " << WTERMSIG( status ) << "." ;
 422                                         throw Exceptions::InternalError( strrefdup( oss ) );
 423                                 }
 424                         else if( WIFSTOPPED( status ) )
 425                                 {
 426                                         ostringstream oss;
 427                                         oss << "pdfLaTeX was stopped by the signal " << WSTOPSIG( status ) << "." ;
 428                                         throw Exceptions::InternalError( strrefdup( oss ) );
 429                                 }
 430                         else
 431                                 {               /* Non-standard case -- may never happen */
 432                                         ostringstream oss;
 433                                         oss << "waitpid for the pdfLaTeX process resulted in the unexpected status 0x" << std::hex << status << "." ;
 434                                         throw Exceptions::InternalError( strrefdup( oss ) );
 435                                 }
 436                 }
 437
 438 }
 439
 440 void
 441 Kernel::TeXLabelManager::loadLabels( RefCountPtr< std::istream > labelsFile )
 442 {
 443         if( ! setupFinalized )
 444                 {
 445                         compileSetupCode( );
 446                 }
 447         ++loadCount;
 448         RefCountPtr< SimplePDF::PDF_in > pdfi = RefCountPtr< SimplePDF::PDF_in >( new SimplePDF::PDF_in( labelsFile ) );
 449
 450         Kernel::thePDFImporter.importBtexEtexThings( pdfi, & availableLabels, setupCodeHash );
 451 }
 452
 453 void
 454 Kernel::TeXLabelManager::setDocumentClass( const Ast::SourceLocation & loc, const char * str )
 455 {
 456         assertNotSetupFinalized( loc );
 457         documentclass = str;
 458 }
 459
 460 void
 461 Kernel::TeXLabelManager::addDocumentOption( const Ast::SourceLocation & loc, const char * str )
 462 {
 463         assertNotSetupFinalized( loc );
 464         documentoptions.push_back( str );
 465 }
 466
 467 void
 468 Kernel::TeXLabelManager::setlmodernT1( const Ast::SourceLocation & loc, bool val )
 469 {
 470         assertNotSetupFinalized( loc );
 471         lmodernT1 = val;
 472 }
 473
 474 void
 475 Kernel::TeXLabelManager::setutf8( const Ast::SourceLocation & loc, bool val )
 476 {
 477         assertNotSetupFinalized( loc );
 478         utf8 = val;
 479 }
 480
 481 void
 482 Kernel::TeXLabelManager::addPreambleLine( const Ast::SourceLocation & loc, const char * line )
 483 {
 484         assertNotSetupFinalized( loc );
 485         preamble << line << endl ;
 486 }
 487
 488 void
 489 Kernel::TeXLabelManager::addDocumentTopLine( const Ast::SourceLocation & loc, const char * line )
 490 {
 491         assertNotSetupFinalized( loc );
 492         documentTop << line << endl ;
 493 }
 494
 495 void
 496 Kernel::TeXLabelManager::assertNotSetupFinalized( const Ast::SourceLocation & loc ) const
 497 {
 498         if( setupFinalized )
 499                 {
 500                         throw Exceptions::TeXSetupTooLate( loc );
 501                 }
 502 }
 503
 504
 505 std::string
 506 Kernel::TeXLabelManager::safeSourceHash( const std::string & str )
 507 {
 508         ostringstream oss;
 509         char tmp[3];
 510         oss << setfill( '0' );
 511         for( const char * src = str.c_str( ); *src != '\0'; ++src )
 512                 {
 513                         if( isspace( *src ) )
 514                                 {
 515                                         oss << "Eb" ;
 516                                         continue;
 517                                 }
 518                         if( *src == 'E' )
 519                                 {
 520                                         oss << "EE" ;
 521                                         continue;
 522                                 }
 523                         if( isalnum( *src ) )
 524                                 {
 525                                         oss << *src ;
 526                                         continue;
 527                                 }
 528                         sprintf( tmp, "%02x", *reinterpret_cast< const unsigned char * >( src ) );
 529                         oss << "Ex" << tmp ;
 530                 }
 531         return oss.str( );
 532 }
 533
 534
 535 void
 536 Kernel::TeXLabelManager::compileSetupCode( )
 537 {
 538         setupFinalized = true;
 539
 540         ostringstream res;
 541         res << "\\documentclass" ;
 542         if( ! documentoptions.empty( ) )
 543                 {
 544                         res << "[" ;
 545                         std::list< std::string >::const_iterator i = documentoptions.begin( );
 546                         res << *i ;
 547                         for( ++i; i != documentoptions.end( ); ++i )
 548                                 {
 549                                         res << "," << *i ;
 550                                 }
 551                         res << "]" ;
 552                 }
 553         res << "{" << documentclass << "}" << endl ;
 554         if( lmodernT1 )
 555                 {
 556                         res << "\\usepackage{lmodern}" << endl ;
 557                         res << "\\usepackage[T1]{fontenc}" << endl ;
 558                 }
 559         if( utf8 )
 560                 {
 561                         res << "\\usepackage[utf8]{inputenc}" << endl ;
 562                 }
 563         res << preamble.str( ) ;
 564         res << "\\newcommand{\\btexetexthing}[3]{%" << endl ;
 565         res << "  \\message{[SHAPES LABEL: #3]}" << endl ;
 566         res << "        \\immediate\\pdfobj stream {#2}" << endl ;
 567         res << "        \\setbox0 = \\hbox{#1}%" << endl ;
 568         res << "        \\pdfxform" << endl ;
 569         res << "                attr {/TeXht /\\the\\ht0 \\space /TeXdp /\\the\\dp0 \\space /TeXwd /\\the\\wd0 \\space /TeXsrc \\the\\pdflastobj \\space 0 R}" << endl ;
 570         res << "                resources{ }" << endl ;
 571         res << "                0" << endl ;
 572         res << "        \\shipout\\hbox{\\pdfrefxform\\pdflastxform}" << endl ;
 573         res << "}" << endl ;
 574
 575         res << "\\begin{document}" << endl ;
 576         res << documentTop.str( ) ;
 577         setupCode = res.str( );
 578         setupCodeHash = safeSourceHash( setupCode );
 579 }
 580
 581
 582 bool
 583 Kernel::TeXLabelManager::isAllBlank( const char * str )
 584 {
 585         for( ; *str != '\0'; ++str )
 586                 {
 587                         if( ! isspace( *str ) )
 588                                 {
 589                                         return false;
 590                                 }
 591                 }
 592         return true;
 593 }
 594
 595 void
 596 Kernel::TeXLabelManager::assertBalanced( const std::string & str, const Kernel::TeXLabelManager::RequestLocation & loc ) const
 597 {
 598         static TeXScanner scanner;
 599         try
 600                 {
 601                         scanner.check( str );
 602                 }
 603         catch( RefCountPtr< const char > msg )
 604                 {
 605                         if( loc.literal_ )
 606                                 {
 607                                         throw Exceptions::StaticTeXLabelError( false, "label", msg, RefCountPtr< const char >( NullPtr< const char >( ) ), loc.loc_ );
 608                                 }
 609                         else
 610                                 {
 611                                         throw Exceptions::TeXLabelError( false, "label", msg, RefCountPtr< const char >( NullPtr< const char >( ) ), loc.loc_ );
 612                                 }
 613                 }
 614 }
 615
 616 void
 617 Kernel::TeXLabelManager::parseTeXErrors( std::istream & interaction )
 618 {
 619         int lastLabel = -2;
 620         const char KEY[] = "[SHAPES LABEL: ";
 621         size_t KEY_LEN = strlen( KEY );
 622         std::string line;
 623         for( std::getline( interaction, line ); ! interaction.eof( ); std::getline( interaction, line ) )
 624                 {
 625                         if( line.compare( 0, 1, "!" ) == 0 )
 626                                 {
 627                                         line = line.substr( 2 );
 628                                         goto found;
 629                                 }
 630                         if( line.compare( 0, KEY_LEN, KEY ) == 0 )
 631                                 {
 632                                         char * endp;
 633                                         lastLabel = strtol( line.c_str( ) + KEY_LEN, & endp, 10 );
 634                                         if( *endp != ']' )
 635                                                 {
 636                                                         throw Exceptions::InternalError( strrefdup( "Failed to scan the label number in: " + line ) );
 637                                                 }
 638                                 }
 639                 }
 640         throw Exceptions::InternalError( "Failed to find an error message in the output from the failing call to pdfLaTeX." );
 641
 642  found:
 643         std::ostringstream message;
 644         {
 645                 std::string tmp;
 646                 size_t lineSize = 0;
 647                 for( std::getline( interaction, tmp ); ! interaction.eof( ); std::getline( interaction, tmp ) )
 648                         {
 649                                 if( lineSize > 0 )
 650                                         {
 651                                                 message << tmp.substr( lineSize ) << std::endl ;
 652                                                 break;
 653                                         }
 654                                 if( tmp.compare( 0, 1, "!" ) == 0 )
 655                                         {
 656                                                 break;
 657                                         }
 658                                 if( tmp.compare( 0, KEY_LEN, KEY ) == 0 )
 659                                         {
 660                                                 break;
 661                                         }
 662                                 if( tmp.compare( 0, 2, "l." ) == 0 )
 663                                         {
 664                                         char * endp;
 665                                         //                                      int dummyLineNo =
 666                                         strtol( tmp.c_str( ) + 2, & endp, 10 );
 667                                         if( *endp != ' ' )
 668                                                 {
 669                                                         throw Exceptions::InternalError( "Expected a space after the line number specification in the output frmo pdfLaTeX." );
 670                                                 }
 671                                         ++endp;
 672                                         lineSize = endp - tmp.c_str( );
 673                                         message << endp << std::endl ;
 674                                         continue;
 675                                         }
 676                                 message << tmp << std::endl ;
 677                         }
 678         }
 679
 680         if( lastLabel == -2 )
 681                 {
 682                         throw Exceptions::StaticTeXLabelError( true, "preamble", strrefdup( line ), strrefdup( message ), Ast::THE_UNKNOWN_LOCATION );
 683                 }
 684         if( lastLabel == -1 )
 685                 {
 686                         throw Exceptions::InternalError( strrefdup( "The TeX setup information caused an error: " + line ) );
 687                 }
 688         {
 689                 int labelIndex = 0;
 690                 typedef typeof currentRequests RequestMapType;
 691                 for( RequestMapType::const_iterator i = currentRequests.begin( );
 692                                  i != currentRequests.end( );
 693                                  ++i, ++labelIndex )
 694                         {
 695                                 if( labelIndex == lastLabel )
 696                                         {
 697                                                 if( i->second.literal_ )
 698                                                         {
 699                                                                 throw Exceptions::StaticTeXLabelError( true, "label", strrefdup( line ), strrefdup( message ), i->second.loc_ );
 700                                                         }
 701                                                 else
 702                                                         {
 703                                                                 throw Exceptions::TeXLabelError( true, "label", strrefdup( line ), strrefdup( message ), i->second.loc_ );
 704                                                         }
 705                                         }
 706                         }
 707                 {
 708                         /* Reaching here is an error.
 709                          */
 710                         std::ostringstream msg;
 711                         msg << "The label index " << lastLabel << " was out of the range (" << currentRequests.size( ) << ")" ;
 712                         throw Exceptions::InternalError( strrefdup( msg ) );
 713                 }
 714         }
 715 }