source/dynamicenvironment.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 <cmath>
  20
  21 #include "Shapes_Helpers_decls.h"
  22
  23 #include "dynamicenvironment.h"
  24 #include "hottypes.h"
  25 #include "globals.h"
  26 #include "shapescore.h"
  27 #include "ast.h"
  28 #include "astvar.h"
  29 #include "isnan.h"
  30 #include "continuations.h"
  31 #include "check.h"
  32
  33 #include <limits>
  34 #include <iomanip>
  35
  36 using namespace Shapes;
  37
  38
  39 void
  40 Kernel::SpecialUnitVariables::specialUnitService( Concrete::Length * d, double * a0, double * a1 )
  41 {
  42         if( p0_ == 0 || p1_ == 0 )
  43                 {
  44                         throw Exceptions::InternalError( "The path points were not setup before calling specialUnitService" );
  45                 }
  46         Concrete::Length x0;
  47         Concrete::Length y0;
  48         Concrete::Length x3;
  49         Concrete::Length y3;
  50         double ag0; /* global angles that will later be compared with aRef */
  51         double ag1;
  52
  53         if( reverseDirection_ )
  54                 {
  55                         x0 = p1_->mid_->x_;
  56                         y0 = p1_->mid_->y_;
  57                         x3 = p0_->mid_->x_;
  58                         y3 = p0_->mid_->y_;
  59                         ag0 = p1_->rearAngle_;
  60                         ag1 = p0_->frontAngle_;
  61                 }
  62         else
  63                 {
  64                         x0 = p0_->mid_->x_;
  65                         y0 = p0_->mid_->y_;
  66                         x3 = p1_->mid_->x_;
  67                         y3 = p1_->mid_->y_;
  68                         ag0 = p0_->frontAngle_;
  69                         ag1 = p1_->rearAngle_;
  70                 }
  71
  72         Concrete::Length dx = x3 - x0;
  73         Concrete::Length dy = y3 - y0;
  74
  75         *d = hypotPhysical( dx, dy );
  76
  77         double aRef = atan2( dy.offtype< 1, 0 >( ), dx.offtype< 1, 0 >( ) );    /* Angles will be relative to the angle pointing to the other mid point */
  78
  79         if( p0_->frontState_ & Concrete::PathPoint2D::FREE_ANGLE )
  80                 {
  81                         throw Exceptions::InternalError( "Found a free angle in specialUnitService." );
  82                 }
  83
  84         if( p1_->rearState_ & Concrete::PathPoint2D::FREE_ANGLE )
  85                 {
  86                         throw Exceptions::InternalError( "Found a free angle in specialUnitService." );
  87                 }
  88
  89         CHECK(
  90                                 if( IS_NAN( ag0 ) )
  91                                         {
  92                                                 std::ostringstream msg;
  93                                                 msg << "Using uninitialized adjacent angle in "
  94                                                                 << "(" << Concrete::Length::offtype( x0 ) << "bp," << Concrete::Length::offtype( y0 ) << "bp)"
  95                                                                 << "--"
  96                                                                 << "(" << Concrete::Length::offtype( x3 ) << "bp," << Concrete::Length::offtype( y3 ) << "bp)" ;
  97                                                 throw Exceptions::InternalError( strrefdup( msg ) );
  98                                         }
  99                                 );
 100
 101         double ar0 = aRef - ag0;
 102         if( ar0 < - M_PI )
 103                 {
 104                         do
 105                                 {
 106                                         ar0 += 2 * M_PI;
 107                                 }
 108                         while( ar0 < - M_PI );
 109                 }
 110         else
 111                 {
 112                         while( ar0 > M_PI )
 113                                 {
 114                                         ar0 -= 2 * M_PI;
 115                                 }
 116                 }
 117
 118         double ar1 = ag1 - aRef - M_PI;
 119         if( IS_NAN( ag1 ) )
 120                 {
 121                         /* The angle is NaN is there is no opposite angle.  The implicit direction is then towards the neighboring point.
 122                          */
 123                         ar1 = 0;
 124                 }
 125         else
 126                 {
 127                         if( ar1 < - M_PI )
 128                                 {
 129                                         do
 130                                                 {
 131                                                         ar1 += 2 * M_PI;
 132                                                 }
 133                                         while( ar1 < - M_PI );
 134                                 }
 135                         else
 136                                 {
 137                                         while( ar1 > M_PI )
 138                                                 {
 139                                                         ar1 -= 2 * M_PI;
 140                                                 }
 141                                 }
 142                 }
 143
 144         if( ar0 < 0 )
 145                 {
 146                         ar0 = - ar0;
 147                         ar1 = - ar1;
 148                 }
 149
 150         ar1 -= ar0;
 151
 152         if( ar1 < - M_PI )
 153                 {
 154                         ar1 += 2 * M_PI;
 155                 }
 156         else if( ar1 > M_PI )
 157                 {
 158                         ar1 -= 2 * M_PI;
 159                 }
 160
 161         *a0 = ar0;
 162         *a1 = ar1;
 163 }
 164
 165 Kernel::SystemDynamicVariables::SystemDynamicVariables( )
 166         : graphicsState_( NullPtr< const Kernel::GraphicsState >( ) ),
 167                 facetState_( NullPtr< const Kernel::FacetState >( ) ),
 168                 textState_( NullPtr< const Kernel::TextState >( ) ),
 169                 eyez_( std::numeric_limits< double >::signaling_NaN( ) ),
 170                 TeX_bleed_( std::numeric_limits< double >::signaling_NaN( ) ),
 171                 defaultUnit_( NullPtr< const Kernel::PolarHandlePromise >( ) ),
 172                 blendSpace_( NullPtr< const Lang::ColorSpace >( ) )
 173 { }
 174
 175 Kernel::SystemDynamicVariables::SystemDynamicVariables( const RefCountPtr< const Kernel::GraphicsState > & graphicsState )
 176         : graphicsState_( graphicsState ),
 177                 facetState_( new Kernel::FacetState( true ) ),
 178                 textState_( new Kernel::TextState( true ) ),
 179                 eyez_( 50 * 72 / 2.54 ), /* 50 cm */
 180                 TeX_bleed_( 0.5 ), /* 0.5 bp */
 181                 defaultUnit_( new Kernel::PolarHandleEmptyPromise( ) ),
 182                 blendSpace_( Lang::THE_INHERITED_COLOR_SPACE )
 183 { }
 184
 185 void
 186 Kernel::SystemDynamicVariables::addFrom( const SystemDynamicVariables & other )
 187 {
 188         if( graphicsState_ == NullPtr< const Kernel::GraphicsState >( ) )
 189                 {
 190                         graphicsState_ = other.graphicsState_;
 191                 }
 192         else if( other.graphicsState_ != NullPtr< const Kernel::GraphicsState >( ) )
 193                 {
 194                         graphicsState_ = RefCountPtr< const Kernel::GraphicsState >( new Kernel::GraphicsState( *graphicsState_, *other.graphicsState_ ) );
 195                 }
 196         /* In the remaining situation, there is nothing to merge, so we're done. */
 197
 198         if( facetState_ == NullPtr< const Kernel::FacetState >( ) )
 199                 {
 200                         facetState_ = other.facetState_;
 201                 }
 202         else if( other.facetState_ != NullPtr< const Kernel::FacetState >( ) )
 203                 {
 204                         facetState_ = RefCountPtr< const Kernel::FacetState >( new Kernel::FacetState( *facetState_, *other.facetState_ ) );
 205                 }
 206         /* In the remaining situation, there is nothing to merge, so we're done. */
 207
 208         if( textState_ == NullPtr< const Kernel::TextState >( ) )
 209                 {
 210                         textState_ = other.textState_;
 211                 }
 212         else if( other.textState_ != NullPtr< const Kernel::TextState >( ) )
 213                 {
 214                         textState_ = RefCountPtr< const Kernel::TextState >( new Kernel::TextState( *textState_, *other.textState_ ) );
 215                 }
 216         /* In the remaining situation, there is nothing to merge, so we're done. */
 217
 218         if( IS_NAN( eyez_ ) )
 219                 {
 220                         eyez_ = other.eyez_;
 221                 }
 222
 223         if( IS_NAN( TeX_bleed_ ) )
 224                 {
 225                         TeX_bleed_ = other.TeX_bleed_;
 226                 }
 227
 228         if( defaultUnit_ == NullPtr< const Kernel::PolarHandlePromise >( ) )
 229                 {
 230                         defaultUnit_ = other.defaultUnit_;
 231                 }
 232
 233         if( blendSpace_ == NullPtr< const Lang::ColorSpace >( ) )
 234                 {
 235                         blendSpace_ = other.blendSpace_;
 236                 }
 237 }
 238
 239 void
 240 Kernel::SystemDynamicVariables::print( std::ostream & os, const std::string & indentation ) const
 241 {
 242         const char * moreIndentation = "  ";
 243
 244         if( graphicsState_ != NullPtr< const Kernel::GraphicsState >( ) )
 245                 {
 246                         os << indentation << "Graphics state bindings:" << std::endl ;
 247                         graphicsState_->print( os, indentation + moreIndentation );
 248                 }
 249
 250         if( textState_ != NullPtr< const Kernel::TextState >( ) )
 251                 {
 252                         os << indentation << "Text state bindings:" << std::endl ;
 253                         textState_->print( os, indentation + moreIndentation );
 254                 }
 255
 256         if( facetState_ != NullPtr< const Kernel::FacetState >( ) )
 257                 {
 258                         os << indentation << "Facet state bindings:" << std::endl ;
 259                         facetState_->print( os, indentation + moreIndentation );
 260                 }
 261
 262         if( ! IS_NAN( eyez_ ) )
 263                 {
 264                         os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_EYEZ << ": " << eyez_ / Interaction::displayUnit << Interaction::displayUnitName << std::endl ;
 265                 }
 266
 267         if( ! IS_NAN( TeX_bleed_ ) )
 268                 {
 269                         os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_TEX_BLEED << ": " << TeX_bleed_ / Interaction::displayUnit << Interaction::displayUnitName << std::endl ;
 270                 }
 271
 272         if( defaultUnit_ != NullPtr< const Kernel::PolarHandlePromise >( ) )
 273                 {
 274                         os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_DEFAULT_UNIT << ": " ;
 275                         defaultUnit_->show( os );
 276                         os << std::endl ;
 277                 }
 278
 279         if( blendSpace_ != NullPtr< const Lang::ColorSpace >( ) )
 280                 {
 281                         os << indentation << Interaction::DYNAMIC_VARIABLE_PREFIX << Lang::DYNAMIC_VARIABLE_ID_BLEND_SPACE << ": " ;
 282                         if( blendSpace_->isInherent( ) )
 283                                 {
 284                                         os << "< inherent >" << std::endl ;
 285                                 }
 286                         else
 287                                 {
 288                                         os << blendSpace_->name( ) << std::endl ;
 289                                 }
 290                 }
 291
 292 }
 293
 294
 295 Kernel::DynamicEnvironment::DynamicEnvironment( const RefCountPtr< const Kernel::GraphicsState > & graphicsState )
 296         : parent_( NullPtr< Kernel::DynamicEnvironment >( ) ), sysBindings_( new Kernel::SystemDynamicVariables( graphicsState ) ),
 297                 specialBindings_( 0 ), spanLast_( 0 ),
 298                 contId_( Lang::CONTINUATION_ID_ERROR ), contVal_( Kernel::ContRef( new Kernel::DefaultErrorContinuation( Ast::theProgram->loc( ) ) ) )
 299 { }
 300
 301 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, const Lang::DynamicBindings & bindings )
 302         : parent_( NullPtr< Kernel::DynamicEnvironment >( ) ), sysBindings_( 0 ), specialBindings_( 0 ), spanLast_( 0 ),
 303                 contId_( 0 ), contVal_( NullPtr< Kernel::Continuation >( ) )
 304 {
 305         bindings.bind( bindings_, & sysBindings_ );
 306         if( sysBindings_ != 0 &&
 307                         sysBindings_->graphicsState_ != NullPtr< const Kernel::GraphicsState >( ) )
 308                 {
 309                         sysBindings_->graphicsState_ =
 310                                 RefCountPtr< const Kernel::GraphicsState >( new Kernel::GraphicsState( *(sysBindings_->graphicsState_),
 311                                                                                                                                                                                                                                                                                                                          *(parent->getGraphicsState( )) ) );
 312                 }
 313         if( sysBindings_ != 0 &&
 314                         sysBindings_->facetState_ != NullPtr< const Kernel::FacetState >( ) )
 315                 {
 316                         sysBindings_->facetState_ =
 317                                 RefCountPtr< const Kernel::FacetState >( new Kernel::FacetState( *(sysBindings_->facetState_),
 318                                                                                                                                                                                                                                                                                                  *(parent->getFacetState( )) ) );
 319                 }
 320         if( sysBindings_ != 0 &&
 321                         sysBindings_->textState_ != NullPtr< const Kernel::TextState >( ) )
 322                 {
 323                         sysBindings_->textState_ =
 324                                 RefCountPtr< const Kernel::TextState >( new Kernel::TextState( *(sysBindings_->textState_),
 325                                                                                                                                                                                                                                                                                          *(parent->getTextState( )) ) );
 326                 }
 327         parent_ = parent->selectParent( parent, bindings_ );
 328 }
 329
 330 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, const RefCountPtr< const Kernel::GraphicsState > & graphicsState )
 331         : parent_( parent ), sysBindings_( new Kernel::SystemDynamicVariables( ) ), specialBindings_( 0 ), spanLast_( 0 ),
 332                 contId_( 0 ), contVal_( NullPtr< Kernel::Continuation >( ) )
 333 {
 334         sysBindings_->graphicsState_ = graphicsState;
 335 }
 336
 337 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, Kernel::SystemDynamicVariables * sysBindings )
 338         : parent_( parent ), sysBindings_( sysBindings ), specialBindings_( 0 ), spanLast_( 0 ),
 339                 contId_( 0 ), contVal_( NullPtr< Kernel::Continuation >( ) )
 340 { }
 341
 342 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, Kernel::SpecialUnitVariables * specialBindings )
 343         : parent_( parent ), sysBindings_( 0 ), specialBindings_( specialBindings ), spanLast_( 0 ),
 344                 contId_( 0 ), contVal_( NullPtr< Kernel::Continuation >( ) )
 345 { }
 346
 347 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, const RefCountPtr< const Lang::Value > & spanLast )
 348         : parent_( parent ), sysBindings_( 0 ), specialBindings_( 0 ), spanLast_( new Kernel::SpanLastValue( spanLast ) ),
 349                 contId_( 0 ), contVal_( NullPtr< Kernel::Continuation >( ) )
 350 { }
 351
 352
 353 Kernel::DynamicEnvironment::DynamicEnvironment( RefCountPtr< Kernel::DynamicEnvironment > parent, const char * contId, const Kernel::ContRef & contVal )
 354         : parent_( parent ), sysBindings_( 0 ), specialBindings_( 0 ), spanLast_( 0 ),
 355                 contId_( contId ), contVal_( contVal )
 356 { }
 357
 358 Kernel::DynamicEnvironment::~DynamicEnvironment( )
 359 {
 360         if( sysBindings_ != 0 )
 361                 {
 362                         delete sysBindings_;
 363                 }
 364         if( specialBindings_ != 0 )
 365                 {
 366                         delete specialBindings_;
 367                 }
 368         if( spanLast_ != 0 )
 369                 {
 370                         delete spanLast_;
 371                 }
 372 }
 373
 374 void
 375 Kernel::DynamicEnvironment::tackOn( const KeyType & key, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
 376 {
 377         throw Exceptions::NotImplemented( "DynamicEnvironment::tackOn" );
 378 //       MapType::iterator i = bindings_.find( key );
 379 //       if( i == bindings_.end( ) )
 380 //               {
 381 //                       if( isBaseEnvironment( ) )
 382 //                               {
 383 //                                       throw Exceptions::InternalError( "Key of dynamic variable was not found in dynamic environment." );
 384 //                               }
 385 //                       return parent_->tackOn( key, evalState, piece, callLoc );
 386 //               }
 387 //       return i->second.first->tackOn( evalState, piece, callLoc );
 388 }
 389
 390 void
 391 Kernel::DynamicEnvironment::lookup( const KeyType & key, Kernel::EvalState * evalState ) const
 392 {
 393         MapType::const_iterator i = bindings_.find( key );
 394         if( i == bindings_.end( ) )
 395                 {
 396                         if( isBaseEnvironment( ) )
 397                                 {
 398                                         throw NonLocalExit::DynamicBindingNotFound( );
 399                                 }
 400                         return parent_->lookup( key, evalState );
 401                 }
 402
 403         Kernel::ContRef cont = evalState->cont_;
 404         cont->takeHandle( i->second.first,
 405                                                                                 evalState );
 406 }
 407
 408 Kernel::VariableHandle
 409 Kernel::DynamicEnvironment::getVarHandle( const KeyType & key ) const
 410 {
 411         MapType::const_iterator i = bindings_.find( key );
 412         if( i == bindings_.end( ) )
 413                 {
 414                         if( isBaseEnvironment( ) )
 415                                 {
 416                                         throw NonLocalExit::DynamicBindingNotFound( );
 417                                 }
 418                         return parent_->getVarHandle( key );
 419                 }
 420         return i->second.first;
 421 }
 422
 423 RefCountPtr< Kernel::DynamicEnvironment >
 424 Kernel::DynamicEnvironment::selectParent( RefCountPtr< Kernel::DynamicEnvironment > & self, const MapType & newBindings )
 425 {
 426         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) ||
 427                         sysBindings_ != 0 ||
 428                         specialBindings_ != 0 ||
 429                         spanLast_ != 0 ||
 430                         contId_ != 0 )
 431                 {
 432                         return self;
 433                 }
 434
 435         MapType::const_iterator hint = newBindings.begin( );
 436         for( MapType::const_iterator i = bindings_.begin( ); i != bindings_.end( ); ++i )
 437                 {
 438                         hint = newBindings.find( i->first );
 439                         if( hint == newBindings.end( ) )
 440                                 {
 441                                         return self;
 442                                 }
 443                 }
 444
 445         return parent_->selectParent( parent_, newBindings );
 446 }
 447
 448 void
 449 Kernel::DynamicEnvironment::gcMark( Kernel::GCMarkedSet & marked )
 450 {
 451         for( MapType::iterator i = bindings_.begin( ); i != bindings_.end( ); ++i )
 452                 {
 453                         i->second.first->gcMark( marked );
 454                 }
 455 }
 456
 457
 458 RefCountPtr< const Kernel::GraphicsState >
 459 Kernel::DynamicEnvironment::getGraphicsState( ) const
 460 {
 461         if( sysBindings_ == 0 ||
 462                         sysBindings_->graphicsState_ == NullPtr< const Kernel::GraphicsState >( ) )
 463                 {
 464                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 465                                 {
 466                                         throw Exceptions::InternalError( "The graphics state was needed but not defined." );
 467                                 }
 468                         return parent_->getGraphicsState( );
 469                 }
 470
 471         return sysBindings_->graphicsState_;
 472 }
 473
 474 RefCountPtr< const Kernel::FacetState >
 475 Kernel::DynamicEnvironment::getFacetState( ) const
 476 {
 477         if( sysBindings_ == 0 ||
 478                         sysBindings_->facetState_ == NullPtr< const Kernel::FacetState >( ) )
 479                 {
 480                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 481                                 {
 482                                         throw Exceptions::InternalError( "The facet state was needed but not defined." );
 483                                 }
 484                         return parent_->getFacetState( );
 485                 }
 486
 487         return sysBindings_->facetState_;
 488 }
 489
 490 RefCountPtr< const Kernel::TextState >
 491 Kernel::DynamicEnvironment::getTextState( ) const
 492 {
 493         if( sysBindings_ == 0 ||
 494                         sysBindings_->textState_ == NullPtr< const Kernel::TextState >( ) )
 495                 {
 496                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 497                                 {
 498                                         throw Exceptions::InternalError( "The text state was needed but not defined." );
 499                                 }
 500                         return parent_->getTextState( );
 501                 }
 502
 503         return sysBindings_->textState_;
 504 }
 505
 506 Concrete::Length
 507 Kernel::DynamicEnvironment::getEyeZ( ) const
 508 {
 509         if( sysBindings_ == 0 ||
 510                         IS_NAN( sysBindings_->eyez_ ) )
 511                 {
 512                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 513                                 {
 514                                         throw Exceptions::InternalError( "@eyez should allways be bound." );
 515                                 }
 516                         return parent_->getEyeZ( );
 517                 }
 518
 519         return sysBindings_->eyez_;
 520 }
 521
 522 Concrete::Length
 523 Kernel::DynamicEnvironment::getTeXBleed( ) const
 524 {
 525         if( sysBindings_ == 0 ||
 526                         IS_NAN( sysBindings_->TeX_bleed_ ) )
 527                 {
 528                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 529                                 {
 530                                         throw Exceptions::InternalError( "@TeX_bleed should allways be bound." );
 531                                 }
 532                         return parent_->getTeXBleed( );
 533                 }
 534
 535         return sysBindings_->TeX_bleed_;
 536 }
 537
 538 RefCountPtr< const Kernel::PolarHandlePromise >
 539 Kernel::DynamicEnvironment::getDefaultUnit( ) const
 540 {
 541         if( sysBindings_ == 0 ||
 542                         sysBindings_->defaultUnit_ == NullPtr< const Kernel::PolarHandlePromise >( ) )
 543                 {
 544                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 545                                 {
 546                                         throw Exceptions::InternalError( "The default unit should allways be defined." );
 547                                 }
 548                         return parent_->getDefaultUnit( );
 549                 }
 550
 551         return sysBindings_->defaultUnit_;
 552 }
 553
 554 RefCountPtr< const Lang::Value >
 555 Kernel::DynamicEnvironment::getSpanLast( ) const
 556 {
 557         if( spanLast_ == 0 )
 558                 {
 559                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 560                                 {
 561                                         throw Exceptions::InternalError( "The value of %last is not determined by the current dynamic context." );
 562                                 }
 563                         return parent_->getSpanLast( );
 564                 }
 565
 566         return spanLast_->last_;
 567 }
 568
 569 Kernel::ContRef
 570 Kernel::DynamicEnvironment::getEscapeContinuation( const char * id, const Ast::SourceLocation & loc ) const
 571 {
 572         if( contId_ == 0 ||
 573                         strcmp( contId_, id ) != 0 )
 574                 {
 575                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 576                                 {
 577                                         throw Exceptions::UndefinedEscapeContinuation( id, loc );
 578                                 }
 579                         return parent_->getEscapeContinuation( id, loc );
 580                 }
 581
 582         return contVal_;
 583 }
 584
 585 RefCountPtr< const Lang::ColorSpace >
 586 Kernel::DynamicEnvironment::getBlendSpace( ) const
 587 {
 588         if( sysBindings_ == 0 ||
 589                         sysBindings_->blendSpace_ == NullPtr< const Lang::ColorSpace >( ) )
 590                 {
 591                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 592                                 {
 593                                         throw Exceptions::InternalError( "The blend space should allways be defined." );
 594                                 }
 595                         return parent_->getBlendSpace( );
 596                 }
 597
 598         return sysBindings_->blendSpace_;
 599 }
 600
 601 void
 602 Kernel::DynamicEnvironment::specialUnitService( Concrete::Length * d, double * a0, double * a1 )
 603 {
 604         if( specialBindings_ != 0 )
 605                 {
 606                         specialBindings_->specialUnitService( d, a0, a1 );
 607                 }
 608         else
 609                 {
 610                         if( parent_ == NullPtr< Kernel::DynamicEnvironment >( ) )
 611                                 {
 612                                         throw Exceptions::InternalError( "The special unit dynamic context was needed but not defined." );
 613                                 }
 614                         parent_->specialUnitService( d, a0, a1 );
 615                 }
 616 }
 617
 618 bool
 619 Kernel::DynamicEnvironment::isBaseEnvironment( ) const
 620 {
 621         return parent_ == NullPtr< Kernel::DynamicEnvironment >( );
 622 }
 623
 624 void
 625 Kernel::DynamicEnvironment::print( std::ostream & os ) const
 626 {
 627         std::set< MapType::key_type > shadowed;
 628         recursivePrint( os, & shadowed );
 629 }
 630
 631 size_t
 632 Kernel::DynamicEnvironment::recursivePrint( std::ostream & os, std::set< MapType::key_type > * shadowed ) const
 633 {
 634         std::set< MapType::key_type > shadowedBefore( *shadowed );
 635
 636         size_t depth = 0;
 637         if( ! isBaseEnvironment( ) )
 638                 {
 639                         for( MapType::const_iterator i = bindings_.begin( ); i != bindings_.end( ); ++i )
 640                                 {
 641                                         shadowed->insert( shadowed->begin( ), i->first );
 642                                 }
 643                         depth = parent_->recursivePrint( os, shadowed ) + 1;
 644                 }
 645
 646         std::string indentation = std::string( depth, ' ' );
 647
 648         os << indentation << "@@ -- -- -- -- -- -- -- -- @@" << std::endl ;
 649
 650         if( contId_ != 0 )
 651                 {
 652                         os << indentation << " (esc) " << "< escape continuation > " << contId_ << ": " << contVal_->traceLoc( ) << " (" << contVal_->description( ) << ")" << std::endl ;
 653                 }
 654
 655         if( sysBindings_ != 0 )
 656                 {
 657                         sysBindings_->print( os, indentation + " (sys) " ); /* The extra indentation matches " (num) "  */
 658                 }
 659
 660         if( specialBindings_ != 0 )
 661                 {
 662                         os << indentation << " (-- ) " << "< special unit points >: " << *(specialBindings_->p0_->mid_) << ( (specialBindings_->reverseDirection_) ? " <-- " : " --> " ) << *(specialBindings_->p1_->mid_) << std::endl ;
 663                 }
 664
 665         if( spanLast_ != 0 )
 666                 {
 667                         os << indentation << " (spn) " << "< %last >: " ;
 668                         spanLast_->last_->show( os );
 669                         os << std::endl ;
 670                 }
 671
 672         for( MapType::const_iterator i = bindings_.begin( ); i != bindings_.end( ); ++i )
 673                 {
 674                         os << indentation ;
 675                         if( shadowedBefore.find( i->first ) != shadowedBefore.end( ) )
 676                                 {
 677                                         os << "#" ;
 678                                 }
 679                         else
 680                                 {
 681                                         os << " " ;
 682                                 }
 683                         os << "(" << std::setw(3) << i->first << ") " << Interaction::DYNAMIC_VARIABLE_PREFIX << i->second.second->id( ) << ": " ;
 684                         if( i->second.first == NullPtr< Kernel::Variable >( ) )
 685                                 {
 686                                         os << "< Uninitialized >" ;
 687                                 }
 688                         else if( i->second.first->isThunk( ) )
 689                                 {
 690                                         os << "< thunk >" ;
 691                                 }
 692                         else if( dynamic_cast< const Lang::Instance * >( i->second.first->getUntyped( ).getPtr( ) ) == 0 )
 693                                 {
 694                                         i->second.first->getUntyped( )->show( os );
 695                                 }
 696                         else
 697                                 {
 698                                         os << "..." ;
 699                                 }
 700                         os << " (" << i->second.second->idLoc( ) << ")" << std::endl ;
 701                 }
 702
 703         //      os << indentation << "-- -- -- -- -- -- -- -- -- --" << std::endl ;
 704
 705         return depth;
 706 }
 707
 708 Lang::EyeZBinding::EyeZBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, Concrete::Length val )
 709         : bindingExpr_( bindingExpr ), val_( val ), id_( id )
 710 { }
 711
 712 Lang::EyeZBinding::~EyeZBinding( )
 713 { }
 714
 715 void
 716 Lang::EyeZBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
 717 {
 718         if( *sysBindings == 0 )
 719                 {
 720                         *sysBindings = new Kernel::SystemDynamicVariables( );
 721                         (*sysBindings)->eyez_ = val_;
 722                         return;
 723                 }
 724
 725         if( ! IS_NAN( (*sysBindings)->eyez_ ) )
 726                 {
 727                         throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
 728                 }
 729
 730         (*sysBindings)->eyez_ = val_;
 731 }
 732
 733 void
 734 Lang::EyeZBinding::show( std::ostream & os ) const
 735 {
 736         os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
 737                  << val_ / Interaction::displayUnit << Interaction::displayUnitName ;
 738 }
 739
 740 void
 741 Lang::EyeZBinding::gcMark( Kernel::GCMarkedSet & marked )
 742 { }
 743
 744
 745
 746 Kernel::EyeZDynamicVariableProperties::EyeZDynamicVariableProperties( const char * _name )
 747         : Kernel::DynamicVariableProperties( _name )
 748 { }
 749
 750 Kernel::EyeZDynamicVariableProperties::~EyeZDynamicVariableProperties( )
 751 { }
 752
 753 Kernel::VariableHandle
 754 Kernel::EyeZDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
 755 {
 756         return Helpers::newValHandle( new Lang::Length( dyn->getEyeZ( ) ) );
 757 }
 758
 759 void
 760 Kernel::EyeZDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
 761 {
 762         try
 763                 {
 764                         RefCountPtr< const Lang::Length > len = val->tryVal< const Lang::Length >( );
 765                         Kernel::ContRef cont = evalState->cont_;
 766                         cont->takeValue( Kernel::ValueRef( new Lang::EyeZBinding( name_, bindingExpr, len->get( ) ) ),
 767                                                                                          evalState );
 768                         return;
 769                 }
 770         catch( const NonLocalExit::NotThisType & ball )
 771                 {
 772                         /* never mind */
 773                 }
 774
 775         try
 776                 {
 777                         RefCountPtr< const Lang::Float > maybeInfinity = val->tryVal< const Lang::Float >( );
 778                         if( maybeInfinity->val_ < HUGE_VAL )
 779                                 {
 780                                         throw Exceptions::OutOfRange( bindingExpr->exprLoc( ), strrefdup( "The only float value allowed here is infinity." ) );
 781                                 }
 782                         Kernel::ContRef cont = evalState->cont_;
 783                         cont->takeValue( Kernel::ValueRef( new Lang::EyeZBinding( name_, bindingExpr, Concrete::HUGE_LENGTH ) ),
 784                                                                                          evalState );
 785                         return;
 786                 }
 787         catch( const NonLocalExit::NotThisType & ball )
 788                 {
 789                         /* never mind */
 790                 }
 791
 792         throw Exceptions::TypeMismatch( bindingExpr->exprLoc( ), val->getUntyped( )->getTypeName( ), Helpers::typeSetString( Lang::Length::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
 793 }
 794
 795
 796 Lang::DefaultUnitBinding::DefaultUnitBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const RefCountPtr< const Kernel::PolarHandlePromise > & val )
 797         : bindingExpr_( bindingExpr ), val_( val ), id_( id )
 798 { }
 799
 800 Lang::DefaultUnitBinding::~DefaultUnitBinding( )
 801 { }
 802
 803 void
 804 Lang::DefaultUnitBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
 805 {
 806         if( *sysBindings == 0 )
 807                 {
 808                         *sysBindings = new Kernel::SystemDynamicVariables( );
 809                         (*sysBindings)->defaultUnit_ = val_;
 810                         return;
 811                 }
 812
 813         if( (*sysBindings)->defaultUnit_ != NullPtr< const Kernel::PolarHandlePromise >( ) )
 814                 {
 815                         throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
 816                 }
 817
 818         (*sysBindings)->defaultUnit_ = val_;
 819 }
 820
 821 void
 822 Lang::DefaultUnitBinding::show( std::ostream & os ) const
 823 {
 824         os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":<promise>" ;
 825 }
 826
 827 void
 828 Lang::DefaultUnitBinding::gcMark( Kernel::GCMarkedSet & marked )
 829 {
 830         val_->gcMark( marked );
 831 }
 832
 833
 834 Kernel::DefaultUnitDynamicVariableProperties::DefaultUnitDynamicVariableProperties( const char * _name )
 835         : Kernel::DynamicVariableProperties( _name )
 836 { }
 837
 838 Kernel::DefaultUnitDynamicVariableProperties::~DefaultUnitDynamicVariableProperties( )
 839 { }
 840
 841 Kernel::VariableHandle
 842 Kernel::DefaultUnitDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
 843 {
 844         throw Exceptions::MiscellaneousRequirement( "The default unit cannot be evaluated as a variable." );
 845 }
 846
 847 void
 848 Kernel::DefaultUnitDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
 849 {
 850         if( ! val->isThunk( ) )
 851                 {
 852                         throw Exceptions::InternalError( "The default unit handle was not a thunk." );
 853                 }
 854
 855         Kernel::ContRef cont = evalState->cont_;
 856         cont->takeValue( Kernel::ValueRef( new Lang::DefaultUnitBinding( name_, bindingExpr, RefCountPtr< const Kernel::PolarHandlePromise >( new Kernel::PolarHandleTruePromise( val->copyThunk( ) ) ) ) ),
 857                                                                          evalState );
 858         return;
 859 }
 860
 861
 862 Lang::TeXBleedBinding::TeXBleedBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, Concrete::Length val )
 863         : bindingExpr_( bindingExpr ), val_( val ), id_( id )
 864 { }
 865
 866 Lang::TeXBleedBinding::~TeXBleedBinding( )
 867 { }
 868
 869 void
 870 Lang::TeXBleedBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
 871 {
 872         if( *sysBindings == 0 )
 873                 {
 874                         *sysBindings = new Kernel::SystemDynamicVariables( );
 875                         (*sysBindings)->TeX_bleed_ = val_;
 876                         return;
 877                 }
 878
 879         if( ! IS_NAN( (*sysBindings)->TeX_bleed_ ) )
 880                 {
 881                         throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
 882                 }
 883
 884         (*sysBindings)->TeX_bleed_ = val_;
 885 }
 886
 887 void
 888 Lang::TeXBleedBinding::show( std::ostream & os ) const
 889 {
 890         os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << ":"
 891                  << val_ / Interaction::displayUnit << Interaction::displayUnitName ;
 892 }
 893
 894 void
 895 Lang::TeXBleedBinding::gcMark( Kernel::GCMarkedSet & marked )
 896 { }
 897
 898
 899
 900 Kernel::TeXBleedDynamicVariableProperties::TeXBleedDynamicVariableProperties( const char * _name )
 901         : Kernel::DynamicVariableProperties( _name )
 902 { }
 903
 904 Kernel::TeXBleedDynamicVariableProperties::~TeXBleedDynamicVariableProperties( )
 905 { }
 906
 907 Kernel::VariableHandle
 908 Kernel::TeXBleedDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
 909 {
 910         return Helpers::newValHandle( new Lang::Length( dyn->getTeXBleed( ) ) );
 911 }
 912
 913 void
 914 Kernel::TeXBleedDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
 915 {
 916         RefCountPtr< const Lang::Length > len = val->getVal< const Lang::Length >( bindingExpr->exprLoc( ) );
 917         Kernel::ContRef cont = evalState->cont_;
 918         cont->takeValue( Kernel::ValueRef( new Lang::TeXBleedBinding( name_, bindingExpr, len->get( ) ) ),
 919                                                                          evalState );
 920 }
 921
 922
 923 Lang::BlendSpaceBinding::BlendSpaceBinding( const char * id, const Ast::DynamicBindingExpression * bindingExpr, const RefCountPtr< const Lang::ColorSpace > & space )
 924         : bindingExpr_( bindingExpr ), space_( space ), id_( id )
 925 { }
 926
 927 Lang::BlendSpaceBinding::~BlendSpaceBinding( )
 928 { }
 929
 930 void
 931 Lang::BlendSpaceBinding::bind( MapType & bindings, Kernel::SystemDynamicVariables ** sysBindings ) const
 932 {
 933         if( *sysBindings == 0 )
 934                 {
 935                         *sysBindings = new Kernel::SystemDynamicVariables( );
 936                         (*sysBindings)->blendSpace_ = space_;
 937                         return;
 938                 }
 939
 940         if( (*sysBindings)->blendSpace_ != NullPtr< const Lang::ColorSpace >( ) )
 941                 {
 942                         throw Exceptions::MultipleDynamicBind( id_, bindingExpr_->idLoc( ), Ast::THE_UNKNOWN_LOCATION );
 943                 }
 944
 945         (*sysBindings)->blendSpace_ = space_;
 946 }
 947
 948 void
 949 Lang::BlendSpaceBinding::show( std::ostream & os ) const
 950 {
 951         os << Interaction::DYNAMIC_VARIABLE_PREFIX << id_ << "" ;
 952         space_->show( os );
 953 }
 954
 955 void
 956 Lang::BlendSpaceBinding::gcMark( Kernel::GCMarkedSet & marked )
 957 { }
 958
 959
 960
 961 Kernel::BlendSpaceDynamicVariableProperties::BlendSpaceDynamicVariableProperties( const char * _name )
 962         : Kernel::DynamicVariableProperties( _name )
 963 { }
 964
 965 Kernel::BlendSpaceDynamicVariableProperties::~BlendSpaceDynamicVariableProperties( )
 966 { }
 967
 968 Kernel::VariableHandle
 969 Kernel::BlendSpaceDynamicVariableProperties::fetch( const Kernel::PassedDyn & dyn ) const
 970 {
 971         return Kernel::VariableHandle( new Kernel::Variable(    dyn->getBlendSpace( ) ) );
 972 }
 973
 974 void
 975 Kernel::BlendSpaceDynamicVariableProperties::makeBinding( Kernel::VariableHandle val, const Ast::DynamicBindingExpression * bindingExpr, Kernel::EvalState * evalState ) const
 976 {
 977         RefCountPtr< const Lang::ColorSpace > space = val->getVal< const Lang::ColorSpace >( bindingExpr->exprLoc( ) );
 978         if( ! space->isBlendable( ) )
 979                 {
 980                         throw Exceptions::OutOfRange( bindingExpr->exprLoc( ), strrefdup( "This color space cannot be used in blending." ) );
 981                 }
 982
 983         Kernel::ContRef cont = evalState->cont_;
 984         cont->takeValue( Kernel::ValueRef( new Lang::BlendSpaceBinding( name_, bindingExpr, space ) ),
 985                                                                          evalState );
 986 }
 987
 988
 989 Kernel::DynamicEnvironment::KeyType Kernel::DynamicEnvironment::nextKey( 0 );
 990
 991 Kernel::DynamicEnvironment::KeyType
 992 Kernel::DynamicEnvironment::getFreshKey( )
 993 {
 994         ++nextKey;
 995         return nextKey;
 996 }
 997
 998
 999
1000 Lang::DynamicExpression::DynamicExpression( Kernel::PassedEnv env, Ast::Expression * expr )
1001         : env_( env ), expr_( expr )
1002 { }
1003
1004 Lang::DynamicExpression::~DynamicExpression( )
1005 { }
1006
1007 RefCountPtr< const Lang::Class > Lang::DynamicExpression::TypeID( new Lang::SystemFinalClass( strrefdup( "DynamicExpression" ) ) );
1008 TYPEINFOIMPL( DynamicExpression );
1009
1010 void
1011 Lang::DynamicExpression::evalHelper( Kernel::EvalState * evalState ) const
1012 {
1013         evalState->env_ = env_;
1014         evalState->expr_ = expr_;
1015 }
1016
1017 void
1018 Lang::DynamicExpression::gcMark( Kernel::GCMarkedSet & marked )
1019 {
1020         env_->gcMark( marked );
1021 }
1022
1023
1024 void
1025 Kernel::registerDynamic( Kernel::Environment * env )
1026 {
1027         env->initDefineDynamic( new Kernel::WidthDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_WIDTH ) );
1028         env->initDefineDynamic( new Kernel::CapStyleDynamicVariableProperties( "cap" ) );
1029         env->initDefineDynamic( new Kernel::JoinStyleDynamicVariableProperties( "join" ) );
1030         env->initDefineDynamic( new Kernel::MiterLimitDynamicVariableProperties( "miterlimit" ) );
1031         env->initDefineDynamic( new Kernel::StrokingDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_STROKING ) );
1032         env->initDefineDynamic( new Kernel::NonStrokingDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_NONSTROKING ) );
1033         env->initDefineDynamic( new Kernel::DashDynamicVariableProperties( "dash" ) );
1034         env->initDefineDynamic( new Kernel::BlendModeDynamicVariableProperties( "blend" ) );
1035         env->initDefineDynamic( new Kernel::AlphaDynamicVariableProperties( "nonstrokingalpha", false ) );
1036         env->initDefineDynamic( new Kernel::AlphaDynamicVariableProperties( "strokingalpha", true ) );
1037
1038         env->initDefineDynamic( new Kernel::ReflectionsDynamicVariableProperties( "reflections" ) );
1039         env->initDefineDynamic( new Kernel::AutoIntensityDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_AUTOINTENSITY ) );
1040         env->initDefineDynamic( new Kernel::AutoScatteringDynamicVariableProperties( "autoscattering" ) );
1041         env->initDefineDynamic( new Kernel::ViewResolutionDynamicVariableProperties( "facetresolution" ) );
1042         env->initDefineDynamic( new Kernel::ShadeOrderDynamicVariableProperties( "shadeorder" ) );
1043
1044         env->initDefineDynamic( new Kernel::CharacterSpacingDynamicVariableProperties( "text_characterspacing" ) );
1045         env->initDefineDynamic( new Kernel::WordSpacingDynamicVariableProperties( "text_wordspacing" ) );
1046         env->initDefineDynamic( new Kernel::HorizontalScalingDynamicVariableProperties( "text_horizontalscaling" ) );
1047         env->initDefineDynamic( new Kernel::LeadingDynamicVariableProperties( "text_leading" ) );
1048         env->initDefineDynamic( new Kernel::FontDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_TEXT_FONT ) );
1049         env->initDefineDynamic( new Kernel::TextSizeDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_TEXT_SIZE ) );
1050         env->initDefineDynamic( new Kernel::TextRenderingModeDynamicVariableProperties( "text_rendering" ) );
1051         env->initDefineDynamic( new Kernel::TextRiseDynamicVariableProperties( "text_rise" ) );
1052         env->initDefineDynamic( new Kernel::TextKnockoutDynamicVariableProperties( "text_knockout" ) );
1053
1054         env->initDefineDynamic( new Kernel::TeXBleedDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_TEX_BLEED ) );
1055
1056         env->initDefineDynamic( new Kernel::EyeZDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_EYEZ ) );
1057         env->initDefineDynamic( new Kernel::DefaultUnitDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_DEFAULT_UNIT ) );
1058         env->initDefineDynamic( new Kernel::BlendSpaceDynamicVariableProperties( Lang::DYNAMIC_VARIABLE_ID_BLEND_SPACE ) );
1059 }
1060