source/identifier.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 2014 Henrik Tidefelt
  17  */
  18
  19 #include "identifier.h"
  20 #include "sourcelocation.h"
  21 #include "consts.h"
  22 #include "check.h"
  23 #include "globals.h"
  24 #include "environment.h"
  25 #include "shapesexceptions.h"
  26
  27 using namespace Shapes;
  28
  29
  30 const RefCountPtr< const Ast::NamespacePath > Ast::THE_EMPTY_NAMESPACE_PATH( new Ast::NamespacePath( ) );
  31 const RefCountPtr< const Ast::SearchContext > Ast::THE_EMPTY_SEARCH_CONTEXT( new Ast::SearchContext( Ast::THE_EMPTY_NAMESPACE_PATH, RefCountPtr< const char >( NullPtr< const char >( ) ) ) );
  32
  33
  34 int
  35 Ast::compare( const Ast::NamespacePath & path1, const Ast::NamespacePath & path2 )
  36 {
  37   if( path1.size( ) < path2.size( ) )
  38     return -1;
  39   if( path1.size( ) > path2.size( ) )
  40     return 1;
  41
  42   Ast::NamespacePath::const_iterator i1 = path1.begin( );
  43   Ast::NamespacePath::const_iterator i2 = path2.begin( );
  44   Ast::NamespacePath::const_iterator end1 = path1.end( );
  45   for( ; i1 != end1; ++i1, ++i2 ){
  46     int cmp = strcmp( *i1, *i2 );
  47     if( cmp < 0 )
  48       return -1;
  49     if( cmp > 0 )
  50       return 1;
  51   }
  52   return 0;
  53 }
  54
  55
  56 //bool
  57 //Ast::operator < ( const Ast::NamespacePath & path1, const Ast::NamespacePath & path2 )
  58 //{
  59 //  return compare( path1, path2 ) < 0;
  60 //}
  61
  62
  63 void
  64 Ast::NamespaceReference::show( std::ostream & os, bool showAbsoluteMark ) const
  65 {
  66   switch( base_ ){
  67   case ABSOLUTE:
  68     if( showAbsoluteMark )
  69       os << Interaction::NAMESPACE_SEPARATOR ;
  70     break;
  71   case LOCAL:
  72     os << Interaction::ENCAPSULATION_MARK ;
  73     break;
  74   case RELATIVE:
  75     break;
  76   }
  77
  78   Ast::NamespacePath::const_iterator i = path_->begin( );
  79   for( ; i != path_->end( ) && Ast::SearchContext::isEncapsulationName( *i ); ++i )
  80     ;
  81   if( i != path_->end( ) ){
  82     os << *i ;
  83     for( ++i; i != path_->end( ); ++i ){
  84       if( ! Ast::SearchContext::isEncapsulationName( *i ) )
  85         os << Interaction::NAMESPACE_SEPARATOR << *i ;
  86     }
  87   }
  88 }
  89
  90
  91 bool
  92 Ast::SearchContext::insideEncapsulationNamespace( ) const
  93 {
  94   if( lexicalPath_->empty( ) )
  95     return false;
  96   /* An alternative condition that could be used below:
  97    *  lexicalPath_.size( ) == encapsulationPath_.size( )
  98    * However, list<>::size is not constant time, so a name-based condition is used instead.
  99    */
 100   return isEncapsulationName( lexicalPath_->back( ) );
 101 }
 102
 103
 104 RefCountPtr< const char >
 105 Ast::SearchContext::makePrivateName( size_t i )
 106 {
 107   std::ostringstream oss;
 108   oss << i ;
 109   return strrefdup( oss );
 110 }
 111
 112
 113 RefCountPtr< const char >
 114 Ast::SearchContext::makeEncapsulationName( size_t i )
 115 {
 116   std::ostringstream oss;
 117   oss << "^" << i ;
 118   return strrefdup( oss );
 119 }
 120
 121
 122 bool
 123 Ast::SearchContext::isEncapsulationName( const char * name )
 124 {
 125   return name[0] == '^';
 126 }
 127
 128
 129 Ast::Identifier::Identifier( const RefCountPtr< const SearchContext > & searchContext, Ast::NamespaceReference::Base base, Ast::NamespacePath * path, const char * simpleId )
 130   : searchContext_( searchContext ), namespaceRef_( base, path ), simpleId_( simpleId )
 131 { }
 132
 133 Ast::Identifier::Identifier( const RefCountPtr< const SearchContext > & searchContext, Ast::NamespaceReference::Base base, const RefCountPtr< const Ast::NamespacePath > & path, const char * simpleId )
 134   : searchContext_( searchContext ), namespaceRef_( base, path ), simpleId_( simpleId )
 135 { }
 136
 137 Ast::Identifier::Identifier( const RefCountPtr< const SearchContext > & searchContext, const NamespaceReference & namespaceRef, const char * simpleId )
 138   : searchContext_( searchContext ), namespaceRef_( namespaceRef ), simpleId_( simpleId )
 139 { }
 140
 141 Ast::Identifier::Identifier( const Ast::Identifier & orig )
 142   : searchContext_( orig.searchContext_ ), namespaceRef_( orig.namespaceRef_ ), simpleId_( orig.simpleId_ )
 143 { }
 144
 145 Ast::Identifier::~Identifier( )
 146 {
 147   /* Note that we intentionally allow simpleId_ to leak here, see memory management note in identifier.h.
 148    */
 149 }
 150
 151 Ast::PlacedIdentifier *
 152 Ast::Identifier::place( const Ast::SourceLocation & loc )
 153 {
 154   if( namespaceRef_.base( ) != Ast::NamespaceReference::RELATIVE || namespaceRef_.path( ).size( ) != 0 ){
 155     Ast::theAnalysisErrorsList.push_back( new Exceptions::ScannerError( loc, strrefdup( "Expected simple identifier." ) ) );
 156   }
 157   Ast::PlacedIdentifier * res = new Ast::PlacedIdentifier( searchContext_->lexicalPath( ), simpleId_ );
 158   simpleId_ = NULL;
 159   return res;
 160 }
 161
 162 const char *
 163 Ast::Identifier::strip( const Ast::SourceLocation & loc )
 164 {
 165   if( namespaceRef_.base( ) != Ast::NamespaceReference::RELATIVE || namespaceRef_.path( ).size( ) != 0 ){
 166     Ast::theAnalysisErrorsList.push_back( new Exceptions::ScannerError( loc, strrefdup( "Expected simple identifier." ) ) );
 167   }
 168   const char * res = simpleId_;
 169   simpleId_ = NULL;
 170   return res;
 171 }
 172
 173 RefCountPtr< const char >
 174 Ast::Identifier::refstrip( const Ast::SourceLocation & loc )
 175 {
 176   if( namespaceRef_.base( ) != Ast::NamespaceReference::RELATIVE || namespaceRef_.path( ).size( ) != 0 ){
 177     Ast::theAnalysisErrorsList.push_back( new Exceptions::ScannerError( loc, strrefdup( "Expected simple identifier." ) ) );
 178   }
 179   RefCountPtr< const char > res( simpleId_ );
 180   simpleId_ = NULL;
 181   return res;
 182 }
 183
 184 void
 185 Ast::Identifier::show( std::ostream & os, Type type, bool showAbsoluteMark ) const
 186 {
 187   namespaceRef_.show( os, showAbsoluteMark );
 188   if( ! namespaceRef_.path( ).empty( ) )
 189     os << Interaction::NAMESPACE_SEPARATOR ;
 190   os << identifierPrefix( type ) << simpleId_ ;
 191 }
 192
 193 void
 194 Ast::Identifier::debugShow( std::ostream & os ) const
 195 {
 196   os << "Identifier: " ;
 197   if( namespaceRef_.base( ) == Ast::NamespaceReference::ABSOLUTE ){
 198     os << Interaction::NAMESPACE_SEPARATOR ;
 199   } else {
 200     os << "(" ;
 201     for( Ast::NamespacePath::const_iterator i = searchContext_->lexicalPath( )->begin( ); i != searchContext_->lexicalPath( )->end( ); ++i ){
 202       os << *i << Interaction::NAMESPACE_SEPARATOR ;
 203     }
 204     os << ") " ;
 205   }
 206
 207   if( namespaceRef_.base( ) == Ast::NamespaceReference::LOCAL )
 208     os << Interaction::ENCAPSULATION_MARK ;
 209
 210   for( Ast::NamespacePath::const_iterator i = namespaceRef_.path( ).begin( ); i != namespaceRef_.path( ).end( ); ++i ){
 211     os << *i << Interaction::NAMESPACE_SEPARATOR ;
 212   }
 213
 214   os << simpleId_ ;
 215
 216 }
 217
 218 bool
 219 Ast::Identifier::operator < ( const Ast::Identifier & other ) const
 220 {
 221   if( base( ) < other.base( ) ){
 222     return true;
 223   }
 224   if( base( ) > other.base( ) ){
 225     return false;
 226   }
 227
 228   Ast::NamespacePath::const_iterator i1 = namespaceRef_.path( ).begin( );
 229   Ast::NamespacePath::const_iterator end1 = namespaceRef_.path( ).end( );
 230   Ast::NamespacePath::const_iterator i2 = other.namespaceRef_.path( ).begin( );
 231   Ast::NamespacePath::const_iterator end2 = other.namespaceRef_.path( ).end( );
 232
 233   while( i1 != end1 && i2 != end2 )
 234   {
 235     int cmp = strcmp( *i1, *i2 );
 236     if( cmp < 0 )
 237       return true;
 238     if( cmp > 0 )
 239       return false;
 240     ++i1;
 241     ++i2;
 242   }
 243
 244   if( i1 != end1 )
 245     return false;
 246   if( i2 != end2 )
 247     return true;
 248
 249   return strcmp( simpleId_, other.simpleId_ ) < 0;
 250 }
 251
 252 const char *
 253 Ast::Identifier::identifierPrefix( Type type )
 254 {
 255   switch( type )
 256   {
 257     case VARIABLE:
 258       return "";
 259     case STATE:
 260       return Interaction::STATE_PREFIX;
 261     case DYNAMIC_VARIABLE:
 262       return Interaction::DYNAMIC_VARIABLE_PREFIX;
 263     case DYNAMIC_STATE:
 264       return Interaction::DYNAMIC_STATE_PREFIX;
 265     case TYPE:
 266       return "";
 267   }
 268 }
 269
 270
 271
 272 Ast::PlacedIdentifier::PlacedIdentifier( const RefCountPtr< const NamespacePath > & absolutePath, const char * simpleId )
 273   : absolutePath_( absolutePath ), simpleId_( simpleId )
 274 { }
 275
 276 Ast::PlacedIdentifier::PlacedIdentifier( Ast::NamespacePath * absolutePath, const char * simpleId )
 277   : absolutePath_( absolutePath ), simpleId_( simpleId )
 278 { }
 279
 280 Ast::PlacedIdentifier::PlacedIdentifier( const Ast::NamespacePath & absolutePath, const char * simpleId )
 281   : absolutePath_( absolutePath ), simpleId_( simpleId )
 282 { }
 283
 284 Ast::PlacedIdentifier::PlacedIdentifier( const Ast::PlacedIdentifier & orig )
 285   : absolutePath_( orig.absolutePath_ ), simpleId_( orig.simpleId_ )
 286 { }
 287
 288 Ast::PlacedIdentifier::~PlacedIdentifier( )
 289 {
 290   /* Note that we intentionally allow simpleId_ to leak here, see memory management note in identifier.h.
 291    */
 292 }
 293
 294 Ast::PlacedIdentifier *
 295 Ast::PlacedIdentifier::clone( ) const
 296 {
 297   /* Here we use that the simpleId_ is not going to be deallocated, so we can share with the constructed object.
 298    */
 299   return new Ast::PlacedIdentifier( absolutePath_, simpleId_ );
 300 }
 301
 302 Ast::Identifier *
 303 Ast::PlacedIdentifier::newAbsolute( ) const
 304 {
 305   /* Here we use that the simpleId_ is not going to be deallocated, so we can share with the constructed object.
 306    */
 307   return new Ast::Identifier( Ast::THE_EMPTY_SEARCH_CONTEXT, Ast::NamespaceReference::ABSOLUTE, absolutePath_, simpleId_ );
 308 }
 309
 310 const char *
 311 Ast::PlacedIdentifier::strip( )
 312 {
 313   const char * res = simpleId_;
 314   simpleId_ = NULL;
 315   return res;
 316 }
 317
 318 RefCountPtr< const char >
 319 Ast::PlacedIdentifier::refstrip( )
 320 {
 321   RefCountPtr< const char > res( simpleId_ );
 322   simpleId_ = NULL;
 323   return res;
 324 }
 325
 326 void
 327 Ast::PlacedIdentifier::show( std::ostream & os, Ast::Identifier::Type type ) const
 328 {
 329   for( Ast::NamespacePath::const_iterator i = absolutePath( ).begin( ); i != absolutePath( ).end( ); ++i ){
 330     if( ! Ast::SearchContext::isEncapsulationName( *i ) )
 331       os << *i << Interaction::NAMESPACE_SEPARATOR ;
 332   }
 333
 334   os << Ast::Identifier::identifierPrefix( type ) << simpleId_ ;
 335 }
 336
 337 bool
 338 Ast::PlacedIdentifier::operator < ( const Ast::PlacedIdentifier & other ) const
 339 {
 340   Ast::NamespacePath::const_iterator i1 = absolutePath( ).begin( );
 341   Ast::NamespacePath::const_iterator end1 = absolutePath( ).end( );
 342   Ast::NamespacePath::const_iterator i2 = other.absolutePath( ).begin( );
 343   Ast::NamespacePath::const_iterator end2 = other.absolutePath( ).end( );
 344
 345   while( i1 != end1 && i2 != end2 )
 346   {
 347     int cmp = strcmp( *i1, *i2 );
 348     if( cmp < 0 )
 349       return true;
 350     if( cmp > 0 )
 351       return false;
 352     ++i1;
 353     ++i2;
 354   }
 355
 356   if( i1 != end1 )
 357     return false;
 358   if( i2 != end2 )
 359     return true;
 360
 361   return strcmp( simpleId_, other.simpleId_ ) < 0;
 362 }