source/sourcelocation.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, 2009 Henrik Tidefelt
  17  */
  18
  19 #include "sourcelocation.h"
  20 #include "charconverters.h"
  21 #include "shapesexceptions.h"
  22 #include "ast.h"
  23 #include "globals.h"
  24 #include "utf8tools.h"
  25 #include "config.h"
  26
  27 #include <cerrno>
  28 #include <fstream>
  29 #include <sstream>
  30 #include <limits>
  31 #include <iomanip>
  32 #include <cstring>
  33
  34 using namespace Shapes;
  35
  36 namespace Shapes
  37 {
  38         namespace Ast
  39         {
  40                 std::map< const Ast::FileID *, Ast::FileInfo *, Ast::FileIDPtrLess > theSourceFiles;
  41         }
  42
  43         namespace Interaction
  44         {
  45                 /* Make sure this is initialized before any SPECIAL file is initialized!
  46                  */
  47                 std::vector< const char * > theInMemorySources;
  48         }
  49
  50         namespace Exceptions
  51         {
  52                 class FileID_OpenError : public Exception
  53                 {
  54                 private:
  55                         const Ast::FileID * fileID_;
  56                         const char * msg_;
  57                 public:
  58                         FileID_OpenError( const Ast::FileID * fileID, const char * msg )
  59                                 : fileID_( fileID ), msg_( msg )
  60                         { }
  61                         virtual ~FileID_OpenError( )
  62                         { }
  63                         virtual void display( std::ostream & os ) const
  64                         {
  65                                 os << Ast::THE_UNKNOWN_LOCATION << locsep << "Low-level source location FileID problem: " << msg_ << std::endl ;
  66                         }
  67                         virtual Interaction::ExitCode exitCode( ) const { return Interaction::EXIT_INTERNAL_ERROR; }
  68                 };
  69         }
  70 }
  71
  72 const char * Ast::FileID::INPUTLIST_PREFIX = "#";
  73 const size_t Ast::FileID::INPUTLIST_PREFIX_LENGTH = Ast::FileID::inputlistPrefixLength( ); /* Don't do before Ast::SourceLocation::INPUTLIST_PREFIX is initialized! */
  74
  75
  76 Ast::FileInfo::FileInfo( const std::string & name )
  77         : name_( name )
  78 { }
  79
  80
  81 Ast::FileID::FileID( Kind kind, dev_t st_dev, ino_t st_ino, const char * strData )
  82         : kind_( kind ), st_dev_( st_dev ), st_ino_( st_ino ), strData_( strData )
  83 { }
  84
  85 const Ast::FileID *
  86 Ast::FileID::build_stat( const struct stat & stat, const std::string & filename )
  87 {
  88         const FileID * tmp = new FileID( NORMAL_FILE, stat.st_dev, stat.st_ino, 0 );
  89         typedef typeof Ast::theSourceFiles MapType;
  90         MapType::iterator i = Ast::theSourceFiles.find( tmp );
  91         if( i != Ast::theSourceFiles.end( ) )
  92                 {
  93                         delete tmp;
  94                         return i->first;
  95                 }
  96         const_cast< FileID * >( tmp )->strData_ = strdup( filename.c_str( ) );
  97         Ast::theSourceFiles.insert( MapType::value_type( tmp, new Ast::FileInfo( filename ) ) );
  98         return tmp;
  99 }
 100
 101 const Ast::FileID *
 102 Ast::FileID::build_inMemory( ino_t index, const std::string & sourceName )
 103 {
 104         const FileID * tmp = new FileID( IN_MEMORY, 0, index, 0 );
 105         typedef typeof Ast::theSourceFiles MapType;
 106         MapType::iterator i = Ast::theSourceFiles.find( tmp );
 107         if( i != Ast::theSourceFiles.end( ) )
 108                 {
 109                         delete tmp;
 110                         return i->first;
 111                 }
 112         Ast::theSourceFiles.insert( MapType::value_type( tmp, new Ast::FileInfo( sourceName ) ) );
 113         return tmp;
 114 }
 115
 116 const Ast::FileID *
 117 Ast::FileID::build_special( const char * specialName )
 118 {
 119         const FileID * tmp = new FileID( SPECIAL, 0, 0, specialName );
 120         typedef typeof Ast::theSourceFiles MapType;
 121         MapType::iterator i = Ast::theSourceFiles.find( tmp );
 122         if( i != Ast::theSourceFiles.end( ) )
 123                 {
 124                         delete tmp;
 125                         return i->first;
 126                 }
 127         Ast::theSourceFiles.insert( MapType::value_type( tmp, 0 ) );
 128         tmp->initInfo( specialName );
 129         return tmp;
 130 }
 131
 132 const Ast::FileID *
 133 Ast::FileID::build_internal( const char * locationName )
 134 {
 135         /* A SPECIAL FileID has no associated FileInfo object in Ast::theSourceFiles.  Instead,
 136          * the name of the source location (which does not have any line or column information by definition)
 137          * is stored directly in the strData_ field.
 138          * For efficiency, we must not make a deep copy of locationName, so the caller must take care of memory
 139          * management.  In most cases locatioName is a string litteral, so then there's no problem.
 140          */
 141         return new FileID( INTERNAL, 0, 0, locationName );
 142 }
 143
 144 bool
 145 Ast::FileID::is_inMemory( const std::string & filename, const FileID ** fileDst )
 146 {
 147         if( strncmp( filename.c_str( ), INPUTLIST_PREFIX, INPUTLIST_PREFIX_LENGTH ) != 0 )
 148                 {
 149                         return 0;
 150                 }
 151         char * end;
 152         ino_t ind = strtol( filename.c_str( ) + INPUTLIST_PREFIX_LENGTH, & end, 10 );
 153         if( *end != '\0' )
 154                 {
 155                         std::ostringstream msg;
 156                         msg << "Error in error message: Failed to extract suffix from inputlist filename: " << filename ;
 157                         Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg ) );
 158                         return false;
 159                 }
 160
 161         if( ind < 0 || Interaction::theInMemorySources.size( ) <= static_cast< size_t >( ind ) ||
 162                         Interaction::theInMemorySources[ ind ] == 0 )
 163                 {
 164                         std::ostringstream msg;
 165                         msg << "Error in error message: Inputlist index " << ind << " is out of range in: " << filename ;
 166                         Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg ) );
 167                         return false;
 168                 }
 169         *fileDst = Ast::FileID::build_inMemory( ind, filename );
 170         return true;
 171 }
 172
 173 void
 174 Ast::FileID::initInfo( const std::string & name ) const
 175 {
 176         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 177         if( res == 0 )
 178                 {
 179                         Ast::theSourceFiles[ this ] = new Ast::FileInfo( name );
 180                 }
 181         else
 182                 {
 183                         std::cerr << "Internal error. Ast::FileID::initInfo called multiple times for the file: " << name << std::endl ;
 184                         exit( Interaction::EXIT_INTERNAL_ERROR );
 185                 }
 186 }
 187
 188 const char *
 189 Ast::FileID::name( ) const
 190 {
 191         if( kind_ == INTERNAL )
 192                 {
 193                         return strData_;
 194                 }
 195         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 196         if( res == 0 )
 197                 {
 198                         std::cerr << "Internal error. Ast::FileID::name called before initializaiton." << std::endl ;
 199                         exit( Interaction::EXIT_INTERNAL_ERROR );
 200                 }
 201         return res->name_.c_str( );
 202 }
 203
 204 std::vector< Ast::Node * > &
 205 Ast::FileID::nodes( ) const
 206 {
 207         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 208         if( res == 0 )
 209                 {
 210                         std::cerr << "Internal error. Ast::FileID::expressions called before initializaiton." << std::endl ;
 211                         exit( Interaction::EXIT_INTERNAL_ERROR );
 212                 }
 213         return res->topLevelNodes_;
 214 }
 215
 216 bool
 217 Ast::FileID::hasPosition( ) const
 218 {
 219         return kind_ != INTERNAL;
 220 }
 221
 222 bool
 223 Ast::FileID::operator < ( const Ast::FileID & other ) const
 224 {
 225         if( kind_ == NORMAL_FILE && other.kind_ != NORMAL_FILE )
 226                 {
 227                         return true;
 228                 }
 229         if( kind_ != NORMAL_FILE && other.kind_ == NORMAL_FILE )
 230                 {
 231                         return false;
 232                 }
 233         if( kind_ == NORMAL_FILE )
 234                 {
 235                         if( st_dev_ < other.st_dev_ )
 236                                 {
 237                                         return true;
 238                                 }
 239                         if( st_dev_ > other.st_dev_ )
 240                                 {
 241                                         return false;
 242                                 }
 243                         return st_ino_ < other.st_ino_;
 244                 }
 245         if( kind_ == IN_MEMORY && other.kind_ != IN_MEMORY )
 246                 {
 247                         return true;
 248                 }
 249         if( kind_ != IN_MEMORY && other.kind_ == IN_MEMORY )
 250                 {
 251                         return false;
 252                 }
 253         if( kind_ == IN_MEMORY )
 254                 {
 255                         return st_ino_ < other.st_ino_;
 256                 }
 257         /* We reach here if both values are SPECIAL or INTERNAL. */
 258         return strData_ < other.strData_;
 259 }
 260
 261 std::istream *
 262 Ast::FileID::open( std::ifstream * ifsMem, std::istringstream * issMem ) const
 263 {
 264         switch( kind_ )
 265                 {
 266                 case NORMAL_FILE:
 267                         {
 268                                 ifsMem->open( strData_ );
 269                                 if( ! ifsMem->is_open( ) )
 270                                         {
 271                                                 throw Exceptions::FileID_OpenError( this, "Failed to open NORMAL file." );
 272                                         }
 273                                 return ifsMem;
 274                         }
 275                 case IN_MEMORY:
 276                         {
 277                                 issMem->str( Interaction::theInMemorySources[ st_ino_ ] );
 278                                 return issMem;
 279                         }
 280                 case SPECIAL:
 281                 case INTERNAL:
 282                         {
 283                                 /* This is an error, see below. */
 284                                 break;
 285                         }
 286                 }
 287         throw Exceptions::FileID_OpenError( this, "FileID::open is not applicable to SPECIAL or INTERNAL files" );
 288 }
 289
 290 void
 291 Ast::FileID::setMem( const char * data )
 292 {
 293         if( kind_ != IN_MEMORY )
 294                 {
 295                         std::cerr << "Internal error: FileID::setMem is only applicable to IN_MEMORY objects." << std::endl ;
 296                         exit( Interaction::EXIT_INTERNAL_ERROR );
 297                 }
 298         if( Interaction::theInMemorySources.size( ) <= st_ino_ )
 299                 {
 300                         Interaction::theInMemorySources.resize( st_ino_ );
 301                 }
 302         Interaction::theInMemorySources[ st_ino_ ] = data;
 303 }
 304
 305 int
 306 Ast::FileID::inMemoryIndex( ) const
 307 {
 308         if( kind_ != IN_MEMORY )
 309                 {
 310                         std::cerr << "Internal error: FileID::inMemoryIndex is only applicable to IN_MEMORY objects." << std::endl ;
 311                         exit( Interaction::EXIT_INTERNAL_ERROR );
 312                 }
 313         return static_cast< int >( st_ino_ );
 314 }
 315
 316 const Ast::FileID *
 317 Ast::FileID::build_fresh_inMemory( )
 318 {
 319         std::ostringstream fullName;
 320         ino_t index = Interaction::theInMemorySources.size( );
 321         fullName << INPUTLIST_PREFIX << index ;
 322         Interaction::theInMemorySources.push_back( 0 );
 323         return Ast::FileID::build_inMemory( index, fullName.str( ) );
 324 }
 325
 326 size_t
 327 Ast::FileID::inputlistPrefixLength( )
 328 {
 329         return strlen( INPUTLIST_PREFIX );
 330 }
 331
 332 Ast::SourceLocation::SourceLocation( )
 333         : file_( Ast::FileID::build_internal( "*bison-uninitialized*" ) ), firstLine( 1 ), firstColumn( 0 ), lastLine( 1 ), lastColumn( 0 )
 334 { }
 335
 336 Ast::SourceLocation::SourceLocation( const Ast::FileID * file )
 337         : file_( file ), firstLine( 1 ), firstColumn( 0 ), lastLine( 1 ), lastColumn( 0 )
 338 { }
 339
 340 Ast::SourceLocation::SourceLocation( const Ast::SourceLocation & orig )
 341         : file_( orig.file_ ), firstLine( orig.firstLine ), firstColumn( orig.firstColumn ), lastLine( orig.lastLine ), lastColumn( orig.lastColumn )
 342 { }
 343
 344 Ast::SourceLocation::SourceLocation( const Ast::SourceLocation & firstLoc, const Ast::SourceLocation & lastLoc )
 345         : file_( firstLoc.file_ ), firstLine( firstLoc.firstLine ), firstColumn( firstLoc.firstColumn ), lastLine( lastLoc.lastLine ), lastColumn( lastLoc.lastColumn )
 346 { }
 347
 348 bool
 349 Ast::SourceLocation::isUnknown( ) const
 350 {
 351         return file_ == SourceLocation::UNKNOWN_FILE;
 352 }
 353
 354 bool
 355 Ast::SourceLocation::contains( const Ast::SourceLocation & loc2 ) const
 356 {
 357         return
 358                 file_ == loc2.file_
 359                 &&
 360                 ( firstLine < loc2.firstLine ||
 361                         ( firstLine == loc2.firstLine && firstColumn <= loc2.firstColumn ) )
 362                 &&
 363                 ( lastLine > loc2.lastLine ||
 364                         ( lastLine == loc2.lastLine && lastColumn >= loc2.lastColumn ) )
 365                 ;
 366 }
 367
 368 std::ostream &
 369 Ast::operator << ( std::ostream & os, const Ast::SourceLocation & self )
 370 {
 371         if( self.file_ == 0 )
 372                 {
 373                         os << "< unknown location >" ;
 374                         return os;
 375                 }
 376
 377         os << self.file_->name( ) ;
 378         if( ! self.file_->hasPosition( ) )
 379                 {
 380                         return os;
 381                 }
 382         os << ":" ;
 383         if( Interaction::characterColumnInBytes )
 384                 {
 385                         if( self.firstLine == self.lastLine )
 386                                 {
 387                                         os << self.firstLine << "(" << self.firstColumn << "-" << self.lastColumn << ")" ;
 388                                 }
 389                         else
 390                                 {
 391                                         os << self.firstLine << "(" << self.firstColumn << ")-" << self.lastLine << "(" << self.lastColumn << ")" ;
 392                                 }
 393                 }
 394         else
 395                 {
 396                         if( self.firstLine == self.lastLine )
 397                                 {
 398                                         os << self.firstLine << "(" ;
 399                                         {
 400                                                 size_t col = self.file_->byteColumnToUTF8Column( self.firstLine, self.firstColumn );
 401                                                 if( col != std::numeric_limits< size_t >::max( ) )
 402                                                         {
 403                                                                 os << col ;
 404                                                         }
 405                                                 else
 406                                                         {
 407                                                                 os << "?" ;
 408                                                         }
 409                                         }
 410                                         os << "-" ;
 411                                         {
 412                                                 size_t col = self.file_->byteColumnToUTF8Column( self.lastLine, self.lastColumn );
 413                                                 if( col != std::numeric_limits< size_t >::max( ) )
 414                                                         {
 415                                                                 os << col ;
 416                                                         }
 417                                                 else
 418                                                         {
 419                                                                 os << "?" ;
 420                                                         }
 421                                         }
 422                                         os << ")" ;
 423                                 }
 424                         else
 425                                 {
 426                                         os << self.firstLine << "(" ;
 427                                         {
 428                                                 size_t col = self.file_->byteColumnToUTF8Column( self.firstLine, self.firstColumn );
 429                                                 if( col != std::numeric_limits< size_t >::max( ) )
 430                                                         {
 431                                                                 os << col ;
 432                                                         }
 433                                                 else
 434                                                         {
 435                                                                 os << "?" ;
 436                                                         }
 437                                         }
 438                                         os << ")-"
 439                                                  << self.lastLine << "(" ;
 440                                         {
 441                                                 size_t col = self.file_->byteColumnToUTF8Column( self.lastLine, self.lastColumn );
 442                                                 if( col != std::numeric_limits< size_t >::max( ) )
 443                                                         {
 444                                                                 os << col ;
 445                                                         }
 446                                                 else
 447                                                         {
 448                                                                 os << "?" ;
 449                                                         }
 450                                         }
 451                                         os << ")" ;
 452                                 }
 453                 }
 454
 455         return os;
 456 }
 457
 458 void
 459 Ast::SourceLocation::copy( std::ostream * os ) const
 460 {
 461         std::ifstream iFile;
 462         std::istringstream iss;
 463         std::istream * is = 0;
 464         try
 465                 {
 466                         is = file_->open( & iFile, & iss );
 467                 }
 468         catch( const Exceptions::FileID_OpenError & ball )
 469                 {
 470                         *os << "[UNABLE-TO-COPY-SOURCE]" ;
 471                         return;
 472                 }
 473
 474         size_t line = 1;
 475         for( ; line < firstLine; ++line )
 476                 {
 477                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 478                 }
 479         is->ignore( firstColumn, '\0' );
 480         std::string tmpLine;
 481         size_t col1 = firstColumn;
 482         for( ; line < lastLine; ++line )
 483                 {
 484                         getline( *is, tmpLine );
 485                         *os << tmpLine << std::endl ;
 486                         col1 = 0;
 487                 }
 488         getline( *is, tmpLine );
 489         *os << tmpLine.substr( 0, lastColumn - col1 ) ;
 490 }
 491
 492 Ast::Expression *
 493 Ast::SourceLocation::findExpression( ) const
 494 {
 495         typedef typeof file_->nodes( ) ListType;
 496         ListType & exprs = file_->nodes( );
 497         for( ListType::iterator i = exprs.begin( ); i != exprs.end( ); ++i )
 498                 {
 499                         Ast::Expression * tmp = (*i)->findExpressionSameFile( *this );
 500                         if( tmp != 0 )
 501                                 {
 502                                         return tmp;
 503                                 }
 504                 }
 505         return 0;
 506 }
 507
 508 size_t
 509 Ast::FileID::byteColumnToUTF8Column( size_t line, size_t byteCol ) const
 510 {
 511         static const Ast::FileID * fileInCache = 0;
 512         static size_t lineInCache = 0;
 513         static std::string cachedLine;
 514
 515         if( byteCol == 0 )
 516                 {
 517                         return 0;
 518                 }
 519
 520         if( this != fileInCache ||
 521                         line != lineInCache )
 522                 {
 523                         fileInCache = this;
 524                         std::ifstream iFile;
 525                         std::istringstream iss;
 526                         std::istream * is = open( & iFile, & iss );
 527                         for( lineInCache = 1; lineInCache < line; ++lineInCache )
 528                                 {
 529                                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 530                                 }
 531                         if( is->eof( ) )
 532                                 {
 533                                         std::ostringstream msg;
 534                                         msg << "Error in error message: Source location's line (" << line << ") is way beyond end of file: " << name( ) ;
 535                                         Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg ) );
 536                                         return 0;
 537                                 }
 538                         getline( *is, cachedLine );
 539                         /* is->eof( ) is acceptable here, since it "just" means that there was no newline
 540                          * terminating the last line in the file.
 541                          */
 542 //                       if( is->eof( ) )
 543 //                               {
 544 //                                      std::ostringstream msg;
 545 //                                      msg << "Error in error message: Source location's line (" << line << ") is one beyond end of file: " << filename ;
 546 //                                      Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg );
 547 //                                       return 0;
 548 //                               }
 549                 }
 550
 551         return byteColumnToUTF8Column( cachedLine, byteCol );
 552 }
 553
 554 size_t
 555 Ast::FileID::byteColumnToUTF8Column( const std::string & line, size_t byteCol )
 556 {
 557         size_t count = 0;
 558         const char * end = line.c_str( ) + byteCol;
 559         for( const char * src = line.c_str( ); src != end && *src != '\0'; ++src )
 560                 {
 561                         if( Helpers::utf8leadByte( *src ) )
 562                                 {
 563                                         ++count;
 564                                 }
 565                 }
 566         return count;
 567 }
 568
 569 size_t
 570 Ast::FileID::UTF8ColumnTobyteColumn( size_t line, size_t utf8Col ) const
 571 {
 572         std::ifstream iFile;
 573         std::istringstream iss;
 574         std::istream * is = open( & iFile, & iss );
 575         for( size_t i = 1; i < line; ++i )
 576                 {
 577                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 578                 }
 579         if( is->eof( ) )
 580                 {
 581                         throw Exceptions::OutOfRange( "Line number is past end of file." );
 582                 }
 583         std::string lineData;
 584         getline( *is, lineData );
 585         return UTF8ColumnTobyteColumn( lineData, utf8Col );
 586 }
 587
 588 size_t
 589 Ast::FileID::UTF8ColumnTobyteColumn( const std::string & line, size_t utf8Col )
 590 {
 591         const char * src = line.c_str( );
 592         for( ; utf8Col > 0 && *src != '\0'; ++src )
 593                 {
 594                         if( Helpers::utf8leadByte( *src ) )
 595                                 {
 596                                         --utf8Col;
 597                                 }
 598                 }
 599         return src - line.c_str( );
 600 }