source/shapesscanner.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, 2010, 2013, 2014, 2015 Henrik Tidefelt
  17  */
  18
  19 #include "shapesscanner.h"
  20 #include "yyltype.h"
  21
  22 #include "shapestypes.h"
  23 #include "ast.h"
  24 #include "astflow.h"
  25 #include "astclass.h"
  26 #include "glyphlist.h"
  27 #include "globals.h"
  28 #include "shapesexceptions.h"
  29
  30 using namespace Shapes;
  31 #include "shapesparser.hh"
  32
  33 #include <iostream>
  34
  35 using namespace std;
  36
  37 bool
  38 operator < ( const NeededFile & n1, const NeededFile & n2 )
  39 {
  40         int cmp = Ast::compare( *(n1.first), *(n2.first) );
  41         if( cmp != 0 )
  42                 return cmp < 0;
  43         return *(n1.second) < *(n2.second);
  44 }
  45
  46
  47 ShapesScanner::ShapesScanner( )
  48         : yyFlexLexer( 0, & std::cerr ), moreState_( false ), lastleng_( 0 ),
  49                 bracketDepth_( 0 ),
  50           searchContext_( new Ast::SearchContext( Ast::THE_EMPTY_NAMESPACE_PATH, Ast::SearchContext::makePrivateName( 0 ) ) ), uniqueNamespaceNumber_( 1 ),
  51                 showFiles_( false ), randSeedSet_( false ), interactive_( false ),
  52                 namespace_( Ast::NamespaceReference::ABSOLUTE, new Ast::NamespacePath( ) )
  53 {
  54         shapeslloc = Ast::THE_UNKNOWN_LOCATION;
  55
  56         angleUnits_[ "rad" ] = 1;
  57         angleUnits_[ "deg" ] = M_PI / 180;
  58         angleUnits_[ "°" ] = M_PI / 180;
  59         angleUnits_[ "grad" ] = M_PI / 200;
  60
  61         lengthUnits_[ "bp" ] = 1;
  62         lengthUnits_[ "mm" ] = 0.1 * 72 / 2.54;
  63         lengthUnits_[ "cm" ] = 72 / 2.54;
  64         lengthUnits_[ "m" ] = 100 * 72 / 2.54;
  65         lengthUnits_[ "in" ] = 72;
  66
  67         namespaceLimits_.push( 0 );
  68         loadStackSizeStack_.push( 0 );
  69         stateStackSizeStack_.push( 0 );
  70 }
  71
  72 ShapesScanner::~ShapesScanner( )
  73 {
  74         while( ! locStack_.empty( ) )
  75                 {
  76                         delete locStack_.top( );
  77                         locStack_.pop( );
  78                 }
  79 }
  80
  81 void
  82 ShapesScanner::setInteractive( bool interactive )
  83 {
  84         interactive_ = interactive;
  85 }
  86
  87 // The following method is placed in shapesyylex to access YY_BUF_SIZE
  88 // ShapesScanner::start( )
  89
  90 void
  91 ShapesScanner::setSourceDir( const std::string & sourceDir )
  92 {
  93         sourceDir_ = sourceDir;
  94 }
  95
  96 void
  97 ShapesScanner::push_backNeedPath( const std::string & path )
  98 {
  99   if( path.empty( ) ){
 100     Interaction::warn_or_push( new Exceptions::InvocationError( "Ignoring empty need entry on need path.", true ), & Ast::theAnalysisErrorsList );
 101   }if( path == "/" ){
 102     /* If the path ends in a '/', it is also a leading '/'. */
 103     needSearchPath_.push_back( path );
 104     loader_.registerNeedDirectory( path );
 105   }else if( path[ path.size( ) - 1 ] == '/' ){
 106     needSearchPath_.push_back( path );
 107     loader_.registerNeedDirectory( path.substr( 0, path.size( ) - 1 ) );
 108   }else{
 109     needSearchPath_.push_back( path + "/" );
 110     loader_.registerNeedDirectory( path );
 111   }
 112 }
 113
 114 void
 115 ShapesScanner::push_frontNeedPath( const std::string & path )
 116 {
 117         if( path.empty( ) ||
 118                         path[ path.size( ) - 1 ] == '/' )
 119                 {
 120                         needSearchPath_.push_front( path );
 121                 }
 122         else
 123                 {
 124                         needSearchPath_.push_front( path + "/" );
 125                 }
 126 }
 127
 128 void
 129 ShapesScanner::pop_frontNeedPath( )
 130 {
 131         needSearchPath_.pop_front( );
 132 }
 133
 134 void
 135 ShapesScanner::setShowFiles( bool showFiles )
 136 {
 137         showFiles_ = showFiles;
 138 }
 139
 140
 141 void
 142 ShapesScanner::more( )
 143 {
 144         moreState_ = true; /* This one is for ourselves to use in doBeforeEachAction. */
 145         yy_more_flag = 1; /* This one is for flex, and will be reset before we reach doBeforeEachAction. */
 146         lastleng_ = yyleng;
 147 }
 148
 149 void
 150 ShapesScanner::doBeforeEachAction( )
 151 {
 152         if( moreState_ )
 153                 {
 154                         shapeslloc.lastColumn += yyleng - lastleng_;
 155                 }
 156         else
 157                 {
 158                         shapeslloc.firstLine = shapeslloc.lastLine;
 159                         shapeslloc.firstColumn = shapeslloc.lastColumn;
 160                         shapeslloc.lastColumn = shapeslloc.firstColumn + yyleng;
 161                 }
 162         moreState_ = false;
 163 }
 164
 165 double
 166 ShapesScanner::lookupLengthUnitFactor( const char * name ) const
 167 {
 168         typedef typeof lengthUnits_ MapType;
 169         MapType::const_iterator i = lengthUnits_.find( name );
 170         if( i == lengthUnits_.end( ) )
 171                 {
 172                         return -1;
 173                 }
 174         return 1 / i->second;
 175 }
 176
 177 Concrete::Length
 178 ShapesScanner::strtoLength( const char * str ) const
 179 {
 180         char * endp;
 181         double scalar = strtod( str, &endp );
 182         typedef typeof lengthUnits_ MapType;
 183         MapType::const_iterator i = lengthUnits_.find( endp );
 184         if( i == lengthUnits_.end( ) )
 185                 {
 186                         throw "Malformed length.";
 187                 }
 188         return scalar * i->second;
 189 }
 190
 191 RefCountPtr< const char >
 192 ShapesScanner::newPrivateName( )
 193 {
 194         RefCountPtr< const char > result = Ast::SearchContext::makePrivateName( uniqueNamespaceNumber_ );
 195         ++uniqueNamespaceNumber_;
 196         return result;
 197 }
 198
 199 RefCountPtr< const char >
 200 ShapesScanner::newEncapsulationName( )
 201 {
 202         RefCountPtr< const char > result = Ast::SearchContext::makeEncapsulationName( uniqueNamespaceNumber_ );
 203         ++uniqueNamespaceNumber_;
 204         return result;
 205 }
 206
 207 void
 208 ShapesScanner::setNamespace( char * str )
 209 {
 210         char * src = str;
 211
 212         Ast::NamespaceReference::Base base = Ast::NamespaceReference::RELATIVE;
 213         switch( *src ){
 214         case '^':
 215                 base = Ast::NamespaceReference::LOCAL;
 216                 src += 2;
 217                 break;
 218         case '.':
 219                 base = Ast::NamespaceReference::ABSOLUTE;
 220                 src += 2;
 221                 break;
 222         default:
 223                 break;
 224         }
 225
 226         Ast::NamespacePath * path = new Ast::NamespacePath( );
 227         char * last;
 228         for( char * tok = strtok_r( src, ".", & last ); tok != NULL; tok = strtok_r( NULL, ".", & last ) ){
 229                 path->push_back( strdup( tok ) );
 230         }
 231
 232         namespace_ = Ast::NamespaceReference( base, path );
 233 }
 234
 235 /* This internal helper function is only meant to work with well-formed identifiers.
 236  */
 237 Ast::Identifier *
 238 ShapesScanner::prependNamespace( const char * idstr ) const
 239 {
 240         return new Ast::Identifier( searchContext_, namespace_, strdup( idstr ) );
 241 }
 242
 243 Shapes::Ast::Identifier *
 244 ShapesScanner::simpleIdentifier( const char * idstr ) const
 245 {
 246         return new Ast::Identifier( searchContext_, Ast::NamespaceReference::RELATIVE, Ast::THE_EMPTY_NAMESPACE_PATH, strdup( idstr ) );
 247 }
 248
 249 Shapes::Ast::PlacedIdentifier *
 250 ShapesScanner::placedIdentifier( const char * idstr ) const
 251 {
 252         return new Ast::PlacedIdentifier( searchContext_->lexicalPath( ), strdup( idstr ) );
 253 }
 254
 255 RefCountPtr< const Ast::NamespacePath >
 256 ShapesScanner::resolvedNamespace( ) const
 257 {
 258         if( namespace_.base( ) == Ast::NamespaceReference::ABSOLUTE )
 259                 return namespace_.pathRef( );
 260
 261         Ast::NamespacePath * resPtr( new Ast::NamespacePath( *(searchContext_->lexicalPath( )) ) );
 262         if( namespace_.base( ) == Ast::NamespaceReference::LOCAL ){
 263                 while ( ! resPtr->empty( ) && ! Ast::SearchContext::isEncapsulationName( resPtr->back( ) ) )
 264                         resPtr->pop_back( );
 265         }
 266
 267         for (Ast::NamespacePath::const_iterator i = namespace_.path( ).begin( ); i != namespace_.path( ).end( ); ++i ){
 268                 resPtr->push_back( *i );
 269         }
 270         return RefCountPtr< const Ast::NamespacePath >( resPtr );
 271 }
 272
 273 std::string
 274 ShapesScanner::searchFile( const std::string & filename, bool runtime ) const
 275 {
 276         struct stat theStatDummy;
 277         std::string res = searchFile( filename, & theStatDummy, runtime );
 278         if( showFiles_ )
 279                 {
 280                         for( size_t i = 0; i < locStack_.size( ); ++i )
 281                                 {
 282                                         std::cerr << "  " ;
 283                                 }
 284                         std::cerr << "  " << res << std::endl ;
 285                 }
 286         return res;
 287 }
 288
 289 std::string
 290 ShapesScanner::searchFile( const std::string & filename, struct stat * dstStat, bool runtime ) const
 291 {
 292         std::string res;
 293
 294         if( filename.empty( ) )
 295                 {
 296                         if( runtime )
 297                                 {
 298                                         throw strrefdup( "Empty file name." ); /* This string should be embedded in a catchable exception by the caller. */
 299                                 }
 300                         else
 301                                 {
 302                                         throw Exceptions::InternalError( strrefdup( "ShapesScanner::searchFile called with empty argument." ) );
 303                                 }
 304                 }
 305
 306         if( filename[ 0 ] == '/' )
 307                 {
 308                         res = filename;
 309                         if( stat( res.c_str( ), dstStat ) == 0 )
 310                                 {
 311                                         return res;
 312                                 }
 313                         if( runtime )
 314                                 {
 315                                         std::ostringstream msg;
 316                                         msg << "The absolute filename \"" << filename << "\" does not name a file." ;
 317                                         throw strrefdup( msg ); /* This string should be embedded in a catchable exception by the caller. */
 318                                 }
 319                         else
 320                                 {
 321                                         throw Exceptions::FileReadOpenError( shapeslloc, strrefdup( filename ), 0, 0 );
 322                                 }
 323                 }
 324
 325         if( needSearchPath_.empty( ) )
 326                 {
 327                         if( runtime )
 328                                 {
 329                                         std::ostringstream msg;
 330                                         msg << "The relative filename \"" << filename << "\" cannot be searched since the search path is empty." ;
 331                                         throw strrefdup( msg ); /* This string should be embedded in a catchable exception by the caller. */
 332                                 }
 333                         else
 334                                 {
 335                                         throw Exceptions::ScannerError( shapeslloc, strrefdup( "Relative file inclusion impossible since search path is empty." ) );
 336                                 }
 337                 }
 338
 339         typedef typeof needSearchPath_ ListType;
 340         for( ListType::const_iterator i = needSearchPath_.begin( ); i != needSearchPath_.end( ); ++i )
 341                 {
 342                         res = needpathWithSuffix( *i, filename );
 343                         if( stat( res.c_str( ), dstStat ) == 0 )
 344                                 {
 345                                         return res;
 346                                 }
 347                 }
 348         if( runtime )
 349                 {
 350                         std::ostringstream msg;
 351                         msg << "The relative filename \"" << filename << "\" did not name a file in the search path." ;
 352                         throw strrefdup( msg ); /* This string should be embedded in a catchable exception by the caller. */
 353                 }
 354         else
 355                 {
 356                         throw Exceptions::FileReadOpenError( shapeslloc, strrefdup( filename ), & sourceDir_, & needSearchPath_ );
 357                 }
 358 }
 359
 360 std::string
 361 ShapesScanner::needpathWithSuffix( const std::string & needpath, const std::string & suffix ) const
 362 {
 363         if( needpath[0] == '/' )
 364                 {
 365                         return needpath + suffix;
 366                 }
 367         else if( needpath == "./" )
 368                 {
 369                         return sourceDir_ + suffix;
 370                 }
 371         else
 372                 {
 373                         return sourceDir_ + needpath + suffix;
 374                 }
 375 }
 376
 377 void
 378 ShapesScanner::rinseString( )
 379 {
 380         /* Both types of strings are terminated by a two byte sequence, ") or ´. */
 381         size_t bytecount = yyleng - ( ( yyleng >= 3 && yytext[ yyleng - 3 ] == '\n' ) ? 3 : 2 );
 382         char * res = new char[ bytecount + 1 ];
 383         memcpy( res, yytext, bytecount );
 384         res[ bytecount ] = '\0';
 385         shapeslval.Lang_String = new Lang::String( RefCountPtr< const char >( res ), bytecount );
 386 }
 387
 388 void
 389 ShapesScanner::concatenateDataString( )
 390 {
 391         /* Remember: strcpy, strdup and friends may fail here, since the string may contain zeros. */
 392
 393         char * res = new char[ dataStringTotalLength_ + 1 ];
 394         char * dst = res;
 395         while( ! dataStringChunks_.empty( ) )
 396                 {
 397                         char * ptr = dataStringChunks_.front( ).first;
 398                         memcpy( dst, ptr, dataStringChunks_.front( ).second );
 399                         dst += dataStringChunks_.front( ).second;
 400                         delete ptr;
 401                         dataStringChunks_.pop_front( );
 402                 }
 403         *dst = '\0';
 404         shapeslval.Lang_String = new Lang::String( RefCountPtr< const char >( res ), dataStringTotalLength_ );
 405 }
 406
 407 uint32_t
 408 ShapesScanner::unicodeFromGlyphname( const char * name )
 409 {
 410         FontMetrics::GlyphList::UnicodeType res;
 411         const FontMetrics::GlyphList & glyphList = Helpers::requireGlyphList( );
 412         if( ! glyphList.name_to_UCS4( name, & res ) )
 413                 {
 414                         std::ostringstream msg;
 415                         msg << "Unrecognized glyph name: " << name ;
 416                         Ast::theAnalysisErrorsList.push_back( new Exceptions::ScannerError( shapeslloc, strrefdup( msg ) ) );
 417                 }
 418         return res;
 419 }