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, 2013, 2014 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   /* Used to first test ( ind < 0 ) below, but I'm currently on a platform where ino_t is unsigned,
 162    * so the test gives a compiler warning.  Hence, rather than checking ( ind < 0 ) we now check that
 163    * the ino_t is unsigned.
 164    */
 165   if( std::numeric_limits< ino_t >::is_signed ){
 166                 Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( "Ast::FileID::is_inMemory: Incorrectly assumed that ino_t is unsigned." ) );
 167                 return false;
 168   }
 169         if( Interaction::theInMemorySources.size( ) <= static_cast< size_t >( ind ) ||
 170                         Interaction::theInMemorySources[ ind ] == 0 )
 171                 {
 172                         std::ostringstream msg;
 173                         msg << "Error in error message: Inputlist index " << ind << " is out of range in: " << filename ;
 174                         Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg ) );
 175                         return false;
 176                 }
 177         *fileDst = Ast::FileID::build_inMemory( ind, filename );
 178         return true;
 179 }
 180
 181 void
 182 Ast::FileID::initInfo( const std::string & name ) const
 183 {
 184         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 185         if( res == 0 )
 186                 {
 187                         Ast::theSourceFiles[ this ] = new Ast::FileInfo( name );
 188                 }
 189         else
 190                 {
 191                         std::cerr << "Internal error. Ast::FileID::initInfo called multiple times for the file: " << name << std::endl ;
 192                         exit( Interaction::EXIT_INTERNAL_ERROR );
 193                 }
 194 }
 195
 196 const char *
 197 Ast::FileID::name( ) const
 198 {
 199         if( kind_ == INTERNAL )
 200                 {
 201                         return strData_;
 202                 }
 203         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 204         if( res == 0 )
 205                 {
 206                         std::cerr << "Internal error. Ast::FileID::name called before initializaiton." << std::endl ;
 207                         exit( Interaction::EXIT_INTERNAL_ERROR );
 208                 }
 209         return res->name_.c_str( );
 210 }
 211
 212 std::vector< Ast::Node * > &
 213 Ast::FileID::nodes( ) const
 214 {
 215         Ast::FileInfo * res = Ast::theSourceFiles[ this ];
 216         if( res == 0 )
 217                 {
 218                         std::cerr << "Internal error. Ast::FileID::nodes called before initializaiton." << std::endl ;
 219                         exit( Interaction::EXIT_INTERNAL_ERROR );
 220                 }
 221         return res->topLevelNodes_;
 222 }
 223
 224 bool
 225 Ast::FileID::hasPosition( ) const
 226 {
 227         return kind_ != INTERNAL;
 228 }
 229
 230 bool
 231 Ast::FileID::operator < ( const Ast::FileID & other ) const
 232 {
 233         if( kind_ == NORMAL_FILE && other.kind_ != NORMAL_FILE )
 234                 {
 235                         return true;
 236                 }
 237         if( kind_ != NORMAL_FILE && other.kind_ == NORMAL_FILE )
 238                 {
 239                         return false;
 240                 }
 241         if( kind_ == NORMAL_FILE )
 242                 {
 243                         if( st_dev_ < other.st_dev_ )
 244                                 {
 245                                         return true;
 246                                 }
 247                         if( st_dev_ > other.st_dev_ )
 248                                 {
 249                                         return false;
 250                                 }
 251                         return st_ino_ < other.st_ino_;
 252                 }
 253         if( kind_ == IN_MEMORY && other.kind_ != IN_MEMORY )
 254                 {
 255                         return true;
 256                 }
 257         if( kind_ != IN_MEMORY && other.kind_ == IN_MEMORY )
 258                 {
 259                         return false;
 260                 }
 261         if( kind_ == IN_MEMORY )
 262                 {
 263                         return st_ino_ < other.st_ino_;
 264                 }
 265         /* We reach here if both values are SPECIAL or INTERNAL. */
 266         return strData_ < other.strData_;
 267 }
 268
 269 std::istream *
 270 Ast::FileID::open( std::ifstream * ifsMem, std::istringstream * issMem ) const
 271 {
 272         switch( kind_ )
 273                 {
 274                 case NORMAL_FILE:
 275                         {
 276                                 ifsMem->open( strData_ );
 277                                 if( ! ifsMem->is_open( ) )
 278                                         {
 279                                                 throw Exceptions::FileID_OpenError( this, "Failed to open NORMAL file." );
 280                                         }
 281                                 return ifsMem;
 282                         }
 283                 case IN_MEMORY:
 284                         {
 285                                 issMem->str( Interaction::theInMemorySources[ st_ino_ ] );
 286                                 return issMem;
 287                         }
 288                 case SPECIAL:
 289                 case INTERNAL:
 290                         {
 291                                 /* This is an error, see below. */
 292                                 break;
 293                         }
 294                 }
 295         throw Exceptions::FileID_OpenError( this, "FileID::open is not applicable to SPECIAL or INTERNAL files" );
 296 }
 297
 298 void
 299 Ast::FileID::setMem( const char * data )
 300 {
 301         if( kind_ != IN_MEMORY )
 302                 {
 303                         std::cerr << "Internal error: FileID::setMem is only applicable to IN_MEMORY objects." << std::endl ;
 304                         exit( Interaction::EXIT_INTERNAL_ERROR );
 305                 }
 306         if( Interaction::theInMemorySources.size( ) <= st_ino_ )
 307                 {
 308                         Interaction::theInMemorySources.resize( st_ino_ );
 309                 }
 310         Interaction::theInMemorySources[ st_ino_ ] = data;
 311 }
 312
 313 int
 314 Ast::FileID::inMemoryIndex( ) const
 315 {
 316         if( kind_ != IN_MEMORY )
 317                 {
 318                         std::cerr << "Internal error: FileID::inMemoryIndex is only applicable to IN_MEMORY objects." << std::endl ;
 319                         exit( Interaction::EXIT_INTERNAL_ERROR );
 320                 }
 321         return static_cast< int >( st_ino_ );
 322 }
 323
 324 const Ast::FileID *
 325 Ast::FileID::build_fresh_inMemory( )
 326 {
 327         std::ostringstream fullName;
 328         ino_t index = Interaction::theInMemorySources.size( );
 329         fullName << INPUTLIST_PREFIX << index ;
 330         Interaction::theInMemorySources.push_back( 0 );
 331         return Ast::FileID::build_inMemory( index, fullName.str( ) );
 332 }
 333
 334 size_t
 335 Ast::FileID::inputlistPrefixLength( )
 336 {
 337         return strlen( INPUTLIST_PREFIX );
 338 }
 339
 340 Ast::SourceLocation::SourceLocation( )
 341         : file_( Ast::FileID::build_internal( "*bison-uninitialized*" ) ), firstLine( 1 ), firstColumn( 0 ), lastLine( 1 ), lastColumn( 0 )
 342 { }
 343
 344 Ast::SourceLocation::SourceLocation( const Ast::FileID * file )
 345         : file_( file ), firstLine( 1 ), firstColumn( 0 ), lastLine( 1 ), lastColumn( 0 )
 346 { }
 347
 348 Ast::SourceLocation::SourceLocation( const Ast::SourceLocation & firstLoc, const Ast::SourceLocation & lastLoc )
 349         : file_( firstLoc.file_ ), firstLine( firstLoc.firstLine ), firstColumn( firstLoc.firstColumn ), lastLine( lastLoc.lastLine ), lastColumn( lastLoc.lastColumn )
 350 { }
 351
 352 Ast::SourceLocation::SourceLocation( const Ast::SourceLocation & orig, bool dummy )
 353         : file_( orig.file_ ), firstLine( orig.firstLine ), firstColumn( orig.firstColumn ), lastLine( orig.lastLine ), lastColumn( orig.lastColumn )
 354 { }
 355
 356 Ast::SourceLocation &
 357 Ast::SourceLocation::operator = ( const Ast::SourceLocation & orig )
 358 {
 359         file_ = orig.file_;
 360         firstLine = orig.firstLine;
 361         firstColumn = orig.firstColumn;
 362         lastLine = orig.lastLine;
 363         lastColumn = orig.lastColumn;
 364         return *this;
 365 }
 366
 367 void
 368 Ast::SourceLocation::swap( SourceLocation * other )
 369 {
 370   SourceLocation tmp( *this, bool( ) );
 371   *this = *other;
 372   *other = tmp;
 373 }
 374
 375 bool
 376 Ast::SourceLocation::isUnknown( ) const
 377 {
 378         return file_ == SourceLocation::UNKNOWN_FILE;
 379 }
 380
 381 bool
 382 Ast::SourceLocation::contains( const Ast::SourceLocation & loc2 ) const
 383 {
 384         return
 385                 file_ == loc2.file_
 386                 &&
 387                 ( firstLine < loc2.firstLine ||
 388                         ( firstLine == loc2.firstLine && firstColumn <= loc2.firstColumn ) )
 389                 &&
 390                 ( lastLine > loc2.lastLine ||
 391                         ( lastLine == loc2.lastLine && lastColumn >= loc2.lastColumn ) )
 392                 ;
 393 }
 394
 395 std::ostream &
 396 Ast::operator << ( std::ostream & os, const Ast::SourceLocation & self )
 397 {
 398         if( self.file_ == 0 )
 399                 {
 400                         os << "< unknown location >" ;
 401                         return os;
 402                 }
 403
 404         os << self.file_->name( ) ;
 405         if( ! self.file_->hasPosition( ) )
 406                 {
 407                         return os;
 408                 }
 409         os << ":" ;
 410         if( Interaction::characterColumnInBytes )
 411                 {
 412                         if( self.firstLine == self.lastLine )
 413                                 {
 414                                         os << self.firstLine << "(" << self.firstColumn << "-" << self.lastColumn << ")" ;
 415                                 }
 416                         else
 417                                 {
 418                                         os << self.firstLine << "(" << self.firstColumn << ")-" << self.lastLine << "(" << self.lastColumn << ")" ;
 419                                 }
 420                 }
 421         else
 422                 {
 423                         if( self.firstLine == self.lastLine )
 424                                 {
 425                                         os << self.firstLine << "(" ;
 426                                         {
 427                                                 size_t col = self.file_->byteColumnToUTF8Column( self.firstLine, self.firstColumn );
 428                                                 if( col != std::numeric_limits< size_t >::max( ) )
 429                                                         {
 430                                                                 os << col ;
 431                                                         }
 432                                                 else
 433                                                         {
 434                                                                 os << "?" ;
 435                                                         }
 436                                         }
 437                                         os << "-" ;
 438                                         {
 439                                                 size_t col = self.file_->byteColumnToUTF8Column( self.lastLine, self.lastColumn );
 440                                                 if( col != std::numeric_limits< size_t >::max( ) )
 441                                                         {
 442                                                                 os << col ;
 443                                                         }
 444                                                 else
 445                                                         {
 446                                                                 os << "?" ;
 447                                                         }
 448                                         }
 449                                         os << ")" ;
 450                                 }
 451                         else
 452                                 {
 453                                         os << self.firstLine << "(" ;
 454                                         {
 455                                                 size_t col = self.file_->byteColumnToUTF8Column( self.firstLine, self.firstColumn );
 456                                                 if( col != std::numeric_limits< size_t >::max( ) )
 457                                                         {
 458                                                                 os << col ;
 459                                                         }
 460                                                 else
 461                                                         {
 462                                                                 os << "?" ;
 463                                                         }
 464                                         }
 465                                         os << ")-"
 466                                                  << self.lastLine << "(" ;
 467                                         {
 468                                                 size_t col = self.file_->byteColumnToUTF8Column( self.lastLine, self.lastColumn );
 469                                                 if( col != std::numeric_limits< size_t >::max( ) )
 470                                                         {
 471                                                                 os << col ;
 472                                                         }
 473                                                 else
 474                                                         {
 475                                                                 os << "?" ;
 476                                                         }
 477                                         }
 478                                         os << ")" ;
 479                                 }
 480                 }
 481
 482         return os;
 483 }
 484
 485 void
 486 Ast::SourceLocation::copy( std::ostream * os ) const
 487 {
 488         std::ifstream iFile;
 489         std::istringstream iss;
 490         std::istream * is = 0;
 491         try
 492                 {
 493                         is = file_->open( & iFile, & iss );
 494                 }
 495         catch( const Exceptions::FileID_OpenError & ball )
 496                 {
 497                         *os << "[UNABLE-TO-COPY-SOURCE]" ;
 498                         return;
 499                 }
 500
 501         size_t line = 1;
 502         for( ; line < firstLine; ++line )
 503                 {
 504                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 505                 }
 506         is->ignore( firstColumn, '\0' );
 507         std::string tmpLine;
 508         size_t col1 = firstColumn;
 509         for( ; line < lastLine; ++line )
 510                 {
 511                         getline( *is, tmpLine );
 512                         *os << tmpLine << std::endl ;
 513                         col1 = 0;
 514                 }
 515         getline( *is, tmpLine );
 516         *os << tmpLine.substr( 0, lastColumn - col1 ) ;
 517 }
 518
 519 Ast::Expression *
 520 Ast::SourceLocation::findExpression( ) const
 521 {
 522         typedef typeof file_->nodes( ) ListType;
 523         ListType & exprs = file_->nodes( );
 524         for( ListType::iterator i = exprs.begin( ); i != exprs.end( ); ++i )
 525                 {
 526                         Ast::Expression * tmp = (*i)->findExpressionSameFile( *this );
 527                         if( tmp != 0 )
 528                                 {
 529                                         return tmp;
 530                                 }
 531                 }
 532         return 0;
 533 }
 534
 535 size_t
 536 Ast::FileID::byteColumnToUTF8Column( size_t line, size_t byteCol ) const
 537 {
 538         static const Ast::FileID * fileInCache = 0;
 539         static size_t lineInCache = 0;
 540         static std::string cachedLine;
 541
 542         if( byteCol == 0 )
 543                 {
 544                         return 0;
 545                 }
 546
 547         if( this != fileInCache ||
 548                         line != lineInCache )
 549                 {
 550                         fileInCache = this;
 551                         std::ifstream iFile;
 552                         std::istringstream iss;
 553                         std::istream * is = open( & iFile, & iss );
 554                         for( lineInCache = 1; lineInCache < line; ++lineInCache )
 555                                 {
 556                                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 557                                 }
 558                         if( is->eof( ) )
 559                                 {
 560                                         std::ostringstream msg;
 561                                         msg << "Error in error message: Source location's line (" << line << ") is way beyond end of file: " << name( ) ;
 562                                         Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg ) );
 563                                         return 0;
 564                                 }
 565                         getline( *is, cachedLine );
 566                         /* is->eof( ) is acceptable here, since it "just" means that there was no newline
 567                          * terminating the last line in the file.
 568                          */
 569 //                       if( is->eof( ) )
 570 //                               {
 571 //                                      std::ostringstream msg;
 572 //                                      msg << "Error in error message: Source location's line (" << line << ") is one beyond end of file: " << filename ;
 573 //                                      Kernel::thePostCheckErrorsList.push_back( new Exceptions::InternalError( msg );
 574 //                                       return 0;
 575 //                               }
 576                 }
 577
 578         return byteColumnToUTF8Column( cachedLine, byteCol );
 579 }
 580
 581 size_t
 582 Ast::FileID::byteColumnToUTF8Column( const std::string & line, size_t byteCol )
 583 {
 584         size_t count = 0;
 585         const char * end = line.c_str( ) + byteCol;
 586         for( const char * src = line.c_str( ); src != end && *src != '\0'; ++src )
 587                 {
 588                         if( Helpers::utf8leadByte( *src ) )
 589                                 {
 590                                         ++count;
 591                                 }
 592                 }
 593         return count;
 594 }
 595
 596 size_t
 597 Ast::FileID::UTF8ColumnTobyteColumn( size_t line, size_t utf8Col ) const
 598 {
 599         std::ifstream iFile;
 600         std::istringstream iss;
 601         std::istream * is = open( & iFile, & iss );
 602         for( size_t i = 1; i < line; ++i )
 603                 {
 604                         is->ignore( std::numeric_limits< std::streamsize >::max( ), '\n' );
 605                 }
 606         if( is->eof( ) )
 607                 {
 608                         throw Exceptions::OutOfRange( "Line number is past end of file." );
 609                 }
 610         std::string lineData;
 611         getline( *is, lineData );
 612         return UTF8ColumnTobyteColumn( lineData, utf8Col );
 613 }
 614
 615 size_t
 616 Ast::FileID::UTF8ColumnTobyteColumn( const std::string & line, size_t utf8Col )
 617 {
 618         const char * src = line.c_str( );
 619         for( ; utf8Col > 0 && *src != '\0'; ++src )
 620                 {
 621                         if( Helpers::utf8leadByte( *src ) )
 622                                 {
 623                                         --utf8Col;
 624                                 }
 625                 }
 626         return src - line.c_str( );
 627 }
 628
 629
 630 Ast::SourceLocationFactory::SourceLocationFactory( )
 631 { }
 632
 633 Ast::SourceLocationFactory::~SourceLocationFactory( )
 634 {
 635         while( ! mem_.empty( ) )
 636                 {
 637                         delete mem_.back( );
 638                         mem_.pop_back( );
 639                 }
 640 }
 641
 642 const Ast::SourceLocation &
 643 Ast::SourceLocationFactory::construct( const FileID * file )
 644 {
 645         Ast::SourceLocation * loc = new Ast::SourceLocation( file );
 646         mem_.push_back( loc );
 647         return *loc;
 648 }
 649
 650 const Ast::SourceLocation &
 651 Ast::SourceLocationFactory::construct_internal( const char * locationName )
 652 {
 653         Ast::SourceLocation * loc = new Ast::SourceLocation( Ast::FileID::build_internal( locationName ) );
 654         mem_.push_back( loc );
 655         return *loc;
 656 }