source/continuations.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, 2013, 2014 Henrik Tidefelt
  17  */
  18
  19 #include "Shapes_Helpers_decls.h"
  20
  21 #include "continuations.h"
  22 #include "hottypes.h"
  23 #include "globals.h"
  24 #include "shapescore.h"
  25 #include "functiontypes.h"
  26 #include "astfun.h"
  27 #include "astvalues.h"
  28 #include "singlelistrange.h"
  29
  30 using namespace Shapes;
  31
  32
  33 Kernel::IfContinuation::IfContinuation( const Kernel::VariableHandle & consequence, const Kernel::VariableHandle & alternative, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
  34         : Kernel::Continuation( traceLoc ), consequence_( consequence ), alternative_( alternative ), cont_( cont )
  35 { }
  36
  37 Kernel::IfContinuation::~IfContinuation( )
  38 { }
  39
  40 void
  41 Kernel::IfContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
  42 {
  43         typedef const Lang::Boolean ArgType;
  44         RefCountPtr< ArgType > arg = Helpers::down_cast_ContinuationArgument< ArgType >( val, this );
  45
  46         if( arg->val_ )
  47                 {
  48                         evalState->cont_ = cont_;
  49                         cont_->takeHandle( consequence_,
  50                                                                                                 evalState );
  51                 }
  52         else
  53                 {
  54                         evalState->cont_ = cont_;
  55                         cont_->takeHandle( alternative_,
  56                                                                                                 evalState );
  57                 }
  58 }
  59
  60 Kernel::ContRef
  61 Kernel::IfContinuation::up( ) const
  62 {
  63         return cont_;
  64 }
  65
  66 RefCountPtr< const char >
  67 Kernel::IfContinuation::description( ) const
  68 {
  69         return strrefdup( "if" );
  70 }
  71
  72 void
  73 Kernel::IfContinuation::gcMark( Kernel::GCMarkedSet & marked )
  74 {
  75         consequence_->gcMark( marked );
  76         alternative_->gcMark( marked );
  77         cont_->gcMark( marked );
  78 }
  79
  80
  81 Kernel::IgnoreContinuation::IgnoreContinuation( const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
  82         : Kernel::Continuation( traceLoc ), cont_( cont )
  83 { }
  84
  85 Kernel::IgnoreContinuation::~IgnoreContinuation( )
  86 { }
  87
  88 void
  89 Kernel::IgnoreContinuation::takeHandle( Kernel::VariableHandle, Kernel::EvalState * evalState, bool dummy ) const
  90 {
  91         evalState->cont_ = cont_;
  92         cont_->takeHandle( Kernel::THE_VOID_VARIABLE, evalState );
  93 }
  94
  95 Kernel::ContRef
  96 Kernel::IgnoreContinuation::up( ) const
  97 {
  98         return cont_;
  99 }
 100
 101 RefCountPtr< const char >
 102 Kernel::IgnoreContinuation::description( ) const
 103 {
 104         return strrefdup( "ignore" );
 105 }
 106
 107 void
 108 Kernel::IgnoreContinuation::gcMark( Kernel::GCMarkedSet & marked )
 109 {
 110         cont_->gcMark( marked );
 111 }
 112
 113
 114 Kernel::IntroduceStateContinuation::IntroduceStateContinuation( const Kernel::PassedEnv & env, size_t * pos, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 115         : Kernel::Continuation( traceLoc ), env_( env ), pos_( pos ), cont_( cont )
 116 { }
 117
 118 Kernel::IntroduceStateContinuation::~IntroduceStateContinuation( )
 119 { }
 120
 121 void
 122 Kernel::IntroduceStateContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 123 {
 124         typedef const Lang::Hot ArgType;
 125         RefCountPtr< ArgType > hot( Helpers::down_cast_ContinuationArgument< ArgType >( val, this ) );
 126         env_->introduceState( *pos_, hot->newState( ) );
 127         evalState->cont_ = cont_;
 128         cont_->takeHandle( Kernel::THE_VOID_VARIABLE, evalState );
 129 }
 130
 131 Kernel::ContRef
 132 Kernel::IntroduceStateContinuation::up( ) const
 133 {
 134         return cont_;
 135 }
 136
 137 RefCountPtr< const char >
 138 Kernel::IntroduceStateContinuation::description( ) const
 139 {
 140         return strrefdup( "introduce state" );
 141 }
 142
 143 void
 144 Kernel::IntroduceStateContinuation::gcMark( Kernel::GCMarkedSet & marked )
 145 {
 146         env_->gcMark( marked );
 147         cont_->gcMark( marked );
 148 }
 149
 150
 151 Kernel::StoreValueContinuation::StoreValueContinuation( Kernel::ValueRef * res, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 152         : Kernel::Continuation( traceLoc ), res_( res ), cont_( cont )
 153 { }
 154
 155 Kernel::StoreValueContinuation::~StoreValueContinuation( )
 156 { }
 157
 158 void
 159 Kernel::StoreValueContinuation::takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
 160 {
 161         if( val->isThunk( ) )
 162                 {
 163                         val->force( val, evalState );
 164                 }
 165         else
 166                 {
 167                         *res_ = val->getUntyped( );
 168                         evalState->cont_ = cont_;
 169                         cont_->takeHandle( val, evalState );
 170                 }
 171 }
 172
 173 Kernel::ContRef
 174 Kernel::StoreValueContinuation::up( ) const
 175 {
 176         return cont_;
 177 }
 178
 179 RefCountPtr< const char >
 180 Kernel::StoreValueContinuation::description( ) const
 181 {
 182         return strrefdup( "store and return" );
 183 }
 184
 185 void
 186 Kernel::StoreValueContinuation::gcMark( Kernel::GCMarkedSet & marked )
 187 {
 188         cont_->gcMark( marked );
 189 }
 190
 191
 192 Kernel::StoreVariableContinuation::StoreVariableContinuation( const Kernel::VariableHandle & dst, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 193         : Kernel::Continuation( traceLoc ), dst_( dst ), cont_( cont )
 194 { }
 195
 196 Kernel::StoreVariableContinuation::~StoreVariableContinuation( )
 197 { }
 198
 199 void
 200 Kernel::StoreVariableContinuation::takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
 201 {
 202         if( val->isThunk( ) )
 203                 {
 204                         val->force( val, evalState );
 205                 }
 206         else
 207                 {
 208                         try{
 209                                 /* This class is friends with Variable, hence setValue is accessible. */
 210                                 dst_->setValue( val->getUntyped( ) );
 211                         }catch( const Exceptions::BadSetValueState & ball ){
 212                                 throw Exceptions::InternalError( traceLoc_, "Multiple uses of continuation that stores value in variable." );
 213                         }
 214                         evalState->cont_ = cont_;
 215                         cont_->takeHandle( val, evalState );
 216                 }
 217 }
 218
 219 Kernel::ContRef
 220 Kernel::StoreVariableContinuation::up( ) const
 221 {
 222         return cont_;
 223 }
 224
 225 RefCountPtr< const char >
 226 Kernel::StoreVariableContinuation::description( ) const
 227 {
 228         return strrefdup( "store and return" );
 229 }
 230
 231 void
 232 Kernel::StoreVariableContinuation::gcMark( Kernel::GCMarkedSet & marked )
 233 {
 234         dst_->gcMark( marked );
 235         cont_->gcMark( marked );
 236 }
 237
 238
 239 Kernel::InsertionContinuation::InsertionContinuation( const Kernel::StateHandle & dst, const Kernel::ContRef & cont, const Kernel::PassedDyn & dyn, const Ast::SourceLocation & traceLoc )
 240         : Kernel::Continuation( traceLoc ), dst_( dst ), dyn_( dyn ), cont_( cont )
 241 { }
 242
 243 Kernel::InsertionContinuation::~InsertionContinuation( )
 244 { }
 245
 246 void
 247 Kernel::InsertionContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 248 {
 249         evalState->cont_ = cont_;
 250         evalState->dyn_ = dyn_;  /* This is how we pass dyn_ to dst_->tackOn .  Additionally passing it as a separate argument is (used to be) very confusing. */
 251         dst_->tackOn( evalState, val, traceLoc_ );
 252 }
 253
 254 Kernel::ContRef
 255 Kernel::InsertionContinuation::up( ) const
 256 {
 257         return cont_;
 258 }
 259
 260 RefCountPtr< const char >
 261 Kernel::InsertionContinuation::description( ) const
 262 {
 263         return strrefdup( "insertion" );
 264 }
 265
 266 void
 267 Kernel::InsertionContinuation::gcMark( Kernel::GCMarkedSet & marked )
 268 {
 269         cont_->gcMark( marked );
 270         dyn_->gcMark( marked );
 271 }
 272
 273
 274 Kernel::StmtStoreValueContinuation::StmtStoreValueContinuation( Kernel::ValueRef * res, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 275         : Kernel::Continuation( traceLoc ), res_( res ), cont_( cont )
 276 { }
 277
 278 Kernel::StmtStoreValueContinuation::~StmtStoreValueContinuation( )
 279 { }
 280
 281 void
 282 Kernel::StmtStoreValueContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 283 {
 284         *res_ = val;
 285         evalState->cont_ = cont_;
 286         cont_->takeHandle( Kernel::THE_VOID_VARIABLE, evalState );
 287 }
 288
 289 Kernel::ContRef
 290 Kernel::StmtStoreValueContinuation::up( ) const
 291 {
 292         return cont_;
 293 }
 294
 295 RefCountPtr< const char >
 296 Kernel::StmtStoreValueContinuation::description( ) const
 297 {
 298         return strrefdup( "statement store (value)" );
 299 }
 300
 301 void
 302 Kernel::StmtStoreValueContinuation::gcMark( Kernel::GCMarkedSet & marked )
 303 {
 304         cont_->gcMark( marked );
 305 }
 306
 307
 308 Kernel::StmtStoreVariableContinuation::StmtStoreVariableContinuation( const Kernel::VariableHandle & dst, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 309         : Kernel::Continuation( traceLoc ), dst_( dst ), cont_( cont )
 310 { }
 311
 312 Kernel::StmtStoreVariableContinuation::~StmtStoreVariableContinuation( )
 313 { }
 314
 315 void
 316 Kernel::StmtStoreVariableContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 317 {
 318         /* This class is friends with Variable, hence setValue is accessible. */
 319         dst_->setValue( val );
 320         evalState->cont_ = cont_;
 321         cont_->takeHandle( Kernel::THE_VOID_VARIABLE, evalState );
 322 }
 323
 324 Kernel::ContRef
 325 Kernel::StmtStoreVariableContinuation::up( ) const
 326 {
 327         return cont_;
 328 }
 329
 330 RefCountPtr< const char >
 331 Kernel::StmtStoreVariableContinuation::description( ) const
 332 {
 333         return strrefdup( "statement store (variable)" );
 334 }
 335
 336 void
 337 Kernel::StmtStoreVariableContinuation::gcMark( Kernel::GCMarkedSet & marked )
 338 {
 339         dst_->gcMark( marked );
 340         cont_->gcMark( marked );
 341 }
 342
 343
 344
 345 Kernel::ForcingContinuation::ForcingContinuation( const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 346         : Kernel::Continuation( traceLoc ), cont_( cont )
 347 { }
 348
 349 Kernel::ForcingContinuation::~ForcingContinuation( )
 350 { }
 351
 352 void
 353 Kernel::ForcingContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 354 {
 355         /* The reason for using this is simply that it only takes values.  Then, the value
 356          * is passed to whatever surrounding continuation.
 357          */
 358         evalState->cont_ = cont_;
 359         cont_->takeValue( val, evalState );
 360 }
 361
 362 Kernel::ContRef
 363 Kernel::ForcingContinuation::up( ) const
 364 {
 365         return cont_;
 366 }
 367
 368 RefCountPtr< const char >
 369 Kernel::ForcingContinuation::description( ) const
 370 {
 371         return strrefdup( "force evaluation" );
 372 }
 373
 374 void
 375 Kernel::ForcingContinuation::gcMark( Kernel::GCMarkedSet & marked )
 376 {
 377         cont_->gcMark( marked );
 378 }
 379
 380
 381 Kernel::ForcingListContinuation::ForcingListContinuation( const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc, bool forceStructures, bool consify )
 382         : Kernel::Continuation( traceLoc ), cont_( cont ), forceStructures_( forceStructures ), consify_( consify ), index_( 0 ), pile_( Lang::THE_CONS_NULL )
 383 { }
 384
 385 Kernel::ForcingListContinuation::ForcingListContinuation( bool forceStructures, bool consify, size_t index, const RefCountPtr< const Lang::SingleList > & pile, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 386         : Kernel::Continuation( traceLoc ), cont_( cont ), forceStructures_( forceStructures ), consify_( consify ), index_( index ), pile_( pile )
 387 { }
 388
 389 Kernel::ForcingListContinuation::~ForcingListContinuation( )
 390 { }
 391
 392 void
 393 Kernel::ForcingListContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 394 {
 395         {
 396                 RefCountPtr< const Lang::SingleList > rest = val.down_cast< const Lang::SingleList >( );
 397                 if( rest != NullPtr< const Lang::SingleList >( ) ){
 398                         RefCountPtr< const Lang::SingleList > pile = pile_;
 399                         RefCountPtr< const Lang::SingleList > result = Lang::THE_CONS_NULL;
 400
 401                         typedef const Lang::SingleListPair PairType;
 402                         PairType * p = dynamic_cast< PairType * >( rest.getPtr( ) );
 403                         if( p != 0 )
 404                                 {
 405                                         if( index_ == 0 && p->isForced( ) ){
 406                                                 /* Efficient code should end up here most of the time. */
 407                                                 if( ! forceStructures_ ){
 408                                                         evalState->cont_ = cont_;
 409                                                         cont_->takeValue( val, evalState );
 410                                                         return;
 411                                                 }
 412                                         }
 413                                         size_t index = index_;
 414                                         while( p != 0 ){
 415                                                 if( p->car_->isThunk( ) ){
 416                                                         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListCarContinuation( forceStructures_, consify_, index, p->cdr_, pile, cont_, traceLoc_ ) );
 417                                                         Kernel::VariableHandle carCopy = p->car_.unconst_cast< Kernel::Variable >( );
 418                                                         carCopy->force( carCopy, evalState );
 419                                                         return;
 420                                                 }
 421                                                 RefCountPtr< const Lang::Value > carVal = p->car_->getUntyped( );
 422                                                 if( forceStructures_ && carVal.down_cast< const Lang::Structure >( ) != NullPtr< const Lang::Structure >( ) ){
 423                                                         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListCarStructureContinuation( consify_, index, p->cdr_, pile, cont_, traceLoc_ ) );
 424                                                         Kernel::ContRef cont = evalState->cont_;
 425                                                         cont->takeValue( carVal, evalState );
 426                                                         return;
 427                                                 }
 428                                                 pile = Helpers::SingleList_cons( carVal, pile );
 429                                                 rest = p->cdr_;
 430                                                 p = dynamic_cast< PairType * >( rest.getPtr( ) );
 431                                                 ++index;
 432                                         }
 433                                 }
 434
 435                         if( rest->isNull( ) ){
 436                                 goto reverse;
 437                         }
 438
 439                         {
 440                                 typedef const Lang::SingleListRange< const Lang::Integer > SpanType;
 441                                 RefCountPtr< SpanType > span = rest.down_cast< SpanType >( );
 442                                 if( span != NullPtr< SpanType >( ) )
 443                                         {
 444                                                 if( index_ == 0 && ! consify_ ){
 445                                                         evalState->cont_ = cont_;
 446                                                         cont_->takeValue( val, evalState ); /* val and rest are the same since index is 0. */
 447                                                         return;
 448                                                 }
 449                                                 if( consify_ ){
 450                                                         result = span->consify( );
 451                                                 }else{
 452                                                         result = span;
 453                                                 }
 454                                                 goto reverse;
 455                                         }
 456                         }
 457                         {
 458                                 typedef const Lang::SingleListRange< const Lang::Float > SpanType;
 459                                 RefCountPtr< SpanType > span = rest.down_cast< SpanType >( );
 460                                 if( span != NullPtr< SpanType >( ) )
 461                                         {
 462                                                 if( index_ == 0 && ! consify_ ){
 463                                                         evalState->cont_ = cont_;
 464                                                         cont_->takeValue( val, evalState ); /* val and rest are the same since index is 0. */
 465                                                         return;
 466                                                 }
 467                                                 if( consify_ ){
 468                                                         result = span->consify( );
 469                                                 }else{
 470                                                         result = span;
 471                                                 }
 472                                                 goto reverse;
 473                                         }
 474                         }
 475                         {
 476                                 typedef const Lang::SingleListRange< const Lang::Length > SpanType;
 477                                 RefCountPtr< SpanType > span = rest.down_cast< SpanType >( );
 478                                 if( span != NullPtr< SpanType >( ) )
 479                                         {
 480                                                 if( index_ == 0 && ! consify_ ){
 481                                                         evalState->cont_ = cont_;
 482                                                         cont_->takeValue( val, evalState ); /* val and rest are the same since index is 0. */
 483                                                         return;
 484                                                 }
 485                                                 if( consify_ ){
 486                                                         result = span->consify( );
 487                                                 }else{
 488                                                         result = span;
 489                                                 }
 490                                                 goto reverse;
 491                                         }
 492                         }
 493
 494                         throw Exceptions::InternalError( "Kernel::ForcingListContinuation::takeValue: Uncovered subtype of SingleList." );
 495
 496                 reverse:
 497                         /* We're done forcing.  Reverse the accumulated result. */
 498                         {
 499                                 typedef const Lang::SingleListPair PairType;
 500                                 PairType * pTyped = dynamic_cast< PairType * >( pile.getPtr( ) );
 501                                 while( pTyped != 0 ){
 502                                         result = RefCountPtr< const Lang::SingleListPair >( new Lang::SingleListPair( pTyped->car_, result ) );
 503                                         pTyped = dynamic_cast< PairType * >( pTyped->cdr_.getPtr( ) );
 504                                 }
 505                         }
 506                         evalState->cont_ = cont_;
 507                         cont_->takeValue( result, evalState );
 508                         return;
 509                 }
 510         }
 511
 512         {
 513                 typedef const Lang::ConsPair PairType;
 514                 PairType * p = dynamic_cast< PairType * >( val.getPtr( ) );
 515                 if( p != 0 )
 516                         {
 517                                 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingConsCarContinuation( forceStructures_, consify_, index_, p->cdr( ), pile_, cont_, traceLoc_ ) );
 518                                 Kernel::VariableHandle carCopy = p->car( ).unconst_cast< Kernel::Variable >( );
 519                                 carCopy->force( carCopy, evalState );
 520                                 return;
 521                         }
 522         }
 523
 524         throw Exceptions::ExpectedList( traceLoc_, index_, val->getTypeName( ) );
 525 }
 526
 527 Kernel::ContRef
 528 Kernel::ForcingListContinuation::up( ) const
 529 {
 530         return cont_;
 531 }
 532
 533 RefCountPtr< const char >
 534 Kernel::ForcingListContinuation::description( ) const
 535 {
 536         return strrefdup( "force all elements in list" );
 537 }
 538
 539 void
 540 Kernel::ForcingListContinuation::gcMark( Kernel::GCMarkedSet & marked )
 541 {
 542         cont_->gcMark( marked );
 543         const_cast< Lang::SingleList * >( pile_.getPtr( ) )->gcMark( marked );
 544 }
 545
 546
 547 Kernel::ForcingListCarContinuation::ForcingListCarContinuation( bool forceStructures, bool consify, size_t index, const RefCountPtr< const Lang::SingleList > & cdr, const RefCountPtr< const Lang::SingleList > & pile, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 548         : Kernel::Continuation( traceLoc ), cont_( cont ), forceStructures_( forceStructures ), consify_( consify ), index_( index ), cdr_( cdr ), pile_( pile )
 549 { }
 550
 551 Kernel::ForcingListCarContinuation::~ForcingListCarContinuation( )
 552 { }
 553
 554 void
 555 Kernel::ForcingListCarContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 556 {
 557         if( forceStructures_ && val.down_cast< const Lang::Structure >( ) != NullPtr< const Lang::Structure >( ) ){
 558                 Kernel::ContRef cont = Kernel::ContRef( new Kernel::ForcingListCarStructureContinuation( consify_, index_, cdr_, pile_, cont_, traceLoc_ ) );
 559                 evalState->cont_ = cont;
 560                 cont->takeValue( val, evalState );
 561                 return;
 562         }
 563
 564         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( forceStructures_, consify_, index_ + 1, Helpers::SingleList_cons( val, pile_ ), cont_, traceLoc_ ) );
 565         Kernel::ContRef cont = evalState->cont_;
 566         cont->takeValue( cdr_, evalState );
 567 }
 568
 569 Kernel::ContRef
 570 Kernel::ForcingListCarContinuation::up( ) const
 571 {
 572         return cont_;
 573 }
 574
 575 RefCountPtr< const char >
 576 Kernel::ForcingListCarContinuation::description( ) const
 577 {
 578         return strrefdup( "force element in list (singly linked)" );
 579 }
 580
 581 void
 582 Kernel::ForcingListCarContinuation::gcMark( Kernel::GCMarkedSet & marked )
 583 {
 584         const_cast< Lang::SingleList * >( cdr_.getPtr( ) )->gcMark( marked );
 585         const_cast< Lang::SingleList * >( pile_.getPtr( ) )->gcMark( marked );
 586         cont_->gcMark( marked );
 587 }
 588
 589 Kernel::ForcingListCarStructureContinuation::ForcingListCarStructureContinuation( bool consify, size_t index, const RefCountPtr< const Lang::SingleList > & cdr, const RefCountPtr< const Lang::SingleList > & pile, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 590         : Kernel::ForcedStructureContinuation( "Forcing structures in list (singly linked)", traceLoc ), cont_( cont ), consify_( consify ), index_( index ), cdr_( cdr ), pile_( pile )
 591 { }
 592
 593 Kernel::ForcingListCarStructureContinuation::~ForcingListCarStructureContinuation( )
 594 { }
 595
 596 void
 597 Kernel::ForcingListCarStructureContinuation::takeStructure( const RefCountPtr< const Lang::Structure > & structure, Kernel::EvalState * evalState ) const
 598 {
 599         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( true, consify_, index_ + 1, Helpers::SingleList_cons( structure, pile_ ), cont_, traceLoc_ ) );
 600         Kernel::ContRef cont = evalState->cont_;
 601         cont->takeValue( cdr_, evalState );
 602 }
 603
 604 Kernel::ContRef
 605 Kernel::ForcingListCarStructureContinuation::up( ) const
 606 {
 607         return cont_;
 608 }
 609
 610 RefCountPtr< const char >
 611 Kernel::ForcingListCarStructureContinuation::description( ) const
 612 {
 613         return strrefdup( "force structure element in list (singly linked)" );
 614 }
 615
 616 void
 617 Kernel::ForcingListCarStructureContinuation::gcMark( Kernel::GCMarkedSet & marked )
 618 {
 619         const_cast< Lang::SingleList * >( cdr_.getPtr( ) )->gcMark( marked );
 620         const_cast< Lang::SingleList * >( pile_.getPtr( ) )->gcMark( marked );
 621         cont_->gcMark( marked );
 622 }
 623
 624 Kernel::ForcingConsCarContinuation::ForcingConsCarContinuation( bool forceStructures, bool consify, size_t index, const Kernel::VariableHandle & cdr, const RefCountPtr< const Lang::SingleList > & pile, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 625         : Kernel::Continuation( traceLoc ), cont_( cont ), forceStructures_( forceStructures ), consify_( consify ), index_( index ), cdr_( cdr ), pile_( pile )
 626 { }
 627
 628 Kernel::ForcingConsCarContinuation::~ForcingConsCarContinuation( )
 629 { }
 630
 631 void
 632 Kernel::ForcingConsCarContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 633 {
 634         if( forceStructures_ && val.down_cast< const Lang::Structure >( ) != NullPtr< const Lang::Structure >( ) ){
 635                 Kernel::ContRef cont = Kernel::ContRef( new Kernel::ForcingConsCarStructureContinuation( consify_, index_, cdr_, pile_, cont_, traceLoc_ ) );
 636                 evalState->cont_ = cont;
 637                 cont->takeValue( val, evalState );
 638                 return;
 639         }
 640
 641         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( forceStructures_, consify_, index_ + 1, Helpers::SingleList_cons( val, pile_ ), cont_, traceLoc_ ) );
 642         Kernel::VariableHandle cdrCopy = cdr_.unconst_cast< Kernel::Variable >( );
 643         cdrCopy->force( cdrCopy, evalState );
 644 }
 645
 646 Kernel::ContRef
 647 Kernel::ForcingConsCarContinuation::up( ) const
 648 {
 649         return cont_;
 650 }
 651
 652 RefCountPtr< const char >
 653 Kernel::ForcingConsCarContinuation::description( ) const
 654 {
 655         return strrefdup( "force element in list (cons)" );
 656 }
 657
 658 void
 659 Kernel::ForcingConsCarContinuation::gcMark( Kernel::GCMarkedSet & marked )
 660 {
 661         cdr_.getPtr( )->gcMark( marked );
 662         const_cast< Lang::SingleList * >( pile_.getPtr( ) )->gcMark( marked );
 663         cont_->gcMark( marked );
 664 }
 665
 666 Kernel::ForcingConsCarStructureContinuation::ForcingConsCarStructureContinuation( bool consify, size_t index, const Kernel::VariableHandle & cdr, const RefCountPtr< const Lang::SingleList > & pile, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 667         : Kernel::ForcedStructureContinuation( "Forcing structures in list (cons list)", traceLoc ), cont_( cont ), consify_( consify ), index_( index ), cdr_( cdr ), pile_( pile )
 668 { }
 669
 670 Kernel::ForcingConsCarStructureContinuation::~ForcingConsCarStructureContinuation( )
 671 { }
 672
 673 void
 674 Kernel::ForcingConsCarStructureContinuation::takeStructure( const RefCountPtr< const Lang::Structure > & structure, Kernel::EvalState * evalState ) const
 675 {
 676         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( true, consify_, index_ + 1, Helpers::SingleList_cons( structure, pile_ ), cont_, traceLoc_ ) );
 677         Kernel::VariableHandle cdrCopy = cdr_.unconst_cast< Kernel::Variable >( );
 678         cdrCopy->force( cdrCopy, evalState );
 679 }
 680
 681 Kernel::ContRef
 682 Kernel::ForcingConsCarStructureContinuation::up( ) const
 683 {
 684         return cont_;
 685 }
 686
 687 RefCountPtr< const char >
 688 Kernel::ForcingConsCarStructureContinuation::description( ) const
 689 {
 690         return strrefdup( "force structure element in list (cons)" );
 691 }
 692
 693 void
 694 Kernel::ForcingConsCarStructureContinuation::gcMark( Kernel::GCMarkedSet & marked )
 695 {
 696         cdr_.getPtr( )->gcMark( marked );
 697         const_cast< Lang::SingleList * >( pile_.getPtr( ) )->gcMark( marked );
 698         cont_->gcMark( marked );
 699 }
 700
 701
 702 Kernel::ExitContinuation::ExitContinuation( bool * done, const Ast::SourceLocation & traceLoc )
 703         : Kernel::Continuation( traceLoc ), done_( done )
 704 { }
 705
 706 Kernel::ExitContinuation::~ExitContinuation( )
 707 { }
 708
 709 void
 710 Kernel::ExitContinuation::takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
 711 {
 712         *done_ = true;
 713 }
 714
 715 Kernel::ContRef
 716 Kernel::ExitContinuation::up( ) const
 717 {
 718         return Kernel::ContRef( NullPtr< Kernel::Continuation >( ) );
 719 }
 720
 721 RefCountPtr< const char >
 722 Kernel::ExitContinuation::description( ) const
 723 {
 724         return strrefdup( "exit (non-forcing)" );
 725 }
 726
 727 void
 728 Kernel::ExitContinuation::gcMark( Kernel::GCMarkedSet & marked )
 729 { }
 730
 731
 732 Kernel::DefaultErrorContinuation::DefaultErrorContinuation( const Ast::SourceLocation & traceLoc )
 733         : Kernel::Continuation( traceLoc )
 734 { }
 735
 736 Kernel::DefaultErrorContinuation::~DefaultErrorContinuation( )
 737 { }
 738
 739 void
 740 Kernel::DefaultErrorContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 741 {
 742         throw Exceptions::UncaughtError( Helpers::down_cast_ContinuationArgument< const Lang::Exception >( val, this ) );
 743 }
 744
 745 Kernel::ContRef
 746 Kernel::DefaultErrorContinuation::up( ) const
 747 {
 748         return Kernel::ContRef( NullPtr< Kernel::Continuation >( ) );
 749 }
 750
 751 RefCountPtr< const char >
 752 Kernel::DefaultErrorContinuation::description( ) const
 753 {
 754         return strrefdup( "default error continuation" );
 755 }
 756
 757 void
 758 Kernel::DefaultErrorContinuation::gcMark( Kernel::GCMarkedSet & marked )
 759 { }
 760
 761
 762 Kernel::Transform2DCont::Transform2DCont( Lang::Transform2D tf, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 763         : Kernel::Continuation( traceLoc ), tf_( tf ), cont_( cont )
 764 { }
 765
 766 Kernel::Transform2DCont::~Transform2DCont( )
 767 { }
 768
 769 void
 770 Kernel::Transform2DCont::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 771 {
 772         try
 773                 {
 774                         typedef const Lang::Geometric2D ArgType;
 775                         RefCountPtr< ArgType > arg = Helpers::try_cast_CoreArgument< ArgType >( val );
 776                         evalState->cont_ = cont_;
 777                         cont_->takeValue( arg->transformed( tf_, arg ),
 778                                                                                                 evalState );
 779                         return;
 780                 }
 781         catch( const NonLocalExit::NotThisType & ball )
 782                 {
 783                         /* Wrong type; never mind!.. but see below!
 784                          */
 785                 }
 786
 787         try
 788                 {
 789                         typedef const Lang::FloatPair ArgType;
 790                         RefCountPtr< ArgType > arg = Helpers::try_cast_CoreArgument< ArgType >( val );
 791                         evalState->cont_ = cont_;
 792                         cont_->takeValue( arg->transformed( tf_ ),
 793                                                                                                 evalState );
 794                         return;
 795                 }
 796         catch( const NonLocalExit::NotThisType & ball )
 797                 {
 798                         /* Wrong type; never mind!.. but see below!
 799                          */
 800                 }
 801
 802         throw Exceptions::ContinuationTypeMismatch( this, val->getTypeName( ), Helpers::typeSetString( Lang::Geometric2D::staticTypeName( ), Lang::FloatPair::staticTypeName( ) ) );
 803 }
 804
 805 Kernel::ContRef
 806 Kernel::Transform2DCont::up( ) const
 807 {
 808         return cont_;
 809 }
 810
 811 RefCountPtr< const char >
 812 Kernel::Transform2DCont::description( ) const
 813 {
 814         return strrefdup( "2D transform application" );
 815 }
 816
 817 void
 818 Kernel::Transform2DCont::gcMark( Kernel::GCMarkedSet & marked )
 819 {
 820         cont_->gcMark( marked );
 821 }
 822
 823
 824 Kernel::Transform3DCont::Transform3DCont( Lang::Transform3D tf, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 825         : Kernel::Continuation( traceLoc ), tf_( tf ), cont_( cont )
 826 { }
 827
 828 Kernel::Transform3DCont::~Transform3DCont( )
 829 { }
 830
 831 void
 832 Kernel::Transform3DCont::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 833 {
 834         try
 835                 {
 836                         typedef const Lang::Geometric3D ArgType;
 837                         RefCountPtr< ArgType > arg = Helpers::try_cast_CoreArgument< ArgType >( val );
 838                         evalState->cont_ = cont_;
 839                         cont_->takeValue( arg->transformed( tf_, arg ),
 840                                                                                                 evalState );
 841                         return;
 842                 }
 843         catch( const NonLocalExit::NotThisType & ball )
 844                 {
 845                         /* Wrong type; never mind!.. but see below!
 846                          */
 847                 }
 848
 849         try
 850                 {
 851                         typedef const Lang::FloatTriple ArgType;
 852                         RefCountPtr< ArgType > arg = Helpers::try_cast_CoreArgument< ArgType >( val );
 853                         evalState->cont_ = cont_;
 854                         cont_->takeValue( arg->transformed( tf_ ),
 855                                                                                                 evalState );
 856                         return;
 857                 }
 858         catch( const NonLocalExit::NotThisType & ball )
 859                 {
 860                         /* Wrong type; never mind!.. but see below!
 861                          */
 862                 }
 863
 864         throw Exceptions::ContinuationTypeMismatch( this, val->getTypeName( ), Helpers::typeSetString( Lang::Geometric3D::staticTypeName( ), Lang::FloatTriple::staticTypeName( ) ) );
 865 }
 866
 867 Kernel::ContRef
 868 Kernel::Transform3DCont::up( ) const
 869 {
 870         return cont_;
 871 }
 872
 873 RefCountPtr< const char >
 874 Kernel::Transform3DCont::description( ) const
 875 {
 876         return strrefdup( "3D transform application" );
 877 }
 878
 879 void
 880 Kernel::Transform3DCont::gcMark( Kernel::GCMarkedSet & marked )
 881 {
 882         cont_->gcMark( marked );
 883 }
 884
 885
 886 Kernel::PathApplication2DCont::PathApplication2DCont( RefCountPtr< const Lang::ElementaryPath2D > path, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 887         : Kernel::Continuation( traceLoc ), path_( path ), cont_( cont )
 888 { }
 889
 890 Kernel::PathApplication2DCont::~PathApplication2DCont( )
 891 { }
 892
 893 void
 894 Kernel::PathApplication2DCont::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 895 {
 896         Concrete::SplineTime t = Helpers::pathTimeCast( path_.getPtr( ), val.getPtr( ), this );
 897
 898         evalState->cont_ = cont_;
 899         cont_->takeValue( Kernel::ValueRef( new Lang::PathSlider2D( path_, t.t( ) ) ),
 900                                                                          evalState );
 901         return;
 902 }
 903
 904 Kernel::ContRef
 905 Kernel::PathApplication2DCont::up( ) const
 906 {
 907         return cont_;
 908 }
 909
 910 RefCountPtr< const char >
 911 Kernel::PathApplication2DCont::description( ) const
 912 {
 913         return strrefdup( "2D path point selection" );
 914 }
 915
 916 void
 917 Kernel::PathApplication2DCont::gcMark( Kernel::GCMarkedSet & marked )
 918 {
 919         const_cast< Lang::ElementaryPath2D * >( path_.getPtr( ) )->gcMark( marked );
 920         cont_->gcMark( marked );
 921 }
 922
 923
 924 Kernel::PathApplication3DCont::PathApplication3DCont( RefCountPtr< const Lang::ElementaryPath3D > path, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
 925         : Kernel::Continuation( traceLoc ), path_( path ), cont_( cont )
 926 { }
 927
 928 Kernel::PathApplication3DCont::~PathApplication3DCont( )
 929 { }
 930
 931 void
 932 Kernel::PathApplication3DCont::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
 933 {
 934         Concrete::SplineTime t = Helpers::pathTimeCast( path_.getPtr( ), val.getPtr( ), this );
 935
 936         evalState->cont_ = cont_;
 937         cont_->takeValue( Kernel::ValueRef( new Lang::PathSlider3D( path_, t.t( ) ) ),
 938                                                                                 evalState );
 939         return;
 940 }
 941
 942 Kernel::ContRef
 943 Kernel::PathApplication3DCont::up( ) const
 944 {
 945         return cont_;
 946 }
 947
 948 RefCountPtr< const char >
 949 Kernel::PathApplication3DCont::description( ) const
 950 {
 951         return strrefdup( "3D path point selection" );
 952 }
 953
 954 void
 955 Kernel::PathApplication3DCont::gcMark( Kernel::GCMarkedSet & marked )
 956 {
 957         const_cast< Lang::ElementaryPath3D * >( path_.getPtr( ) )->gcMark( marked );
 958         cont_->gcMark( marked );
 959 }
 960
 961
 962 Kernel::ComposedFunctionCall_cont::ComposedFunctionCall_cont( const RefCountPtr< const Lang::Function > & second, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
 963         : Kernel::Continuation( callLoc ), second_( second ), dyn_( dyn ), cont_( cont )
 964 { }
 965
 966 Kernel::ComposedFunctionCall_cont::~ComposedFunctionCall_cont( )
 967 { }
 968
 969 void
 970 Kernel::ComposedFunctionCall_cont::takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
 971 {
 972         evalState->dyn_ = dyn_;
 973         evalState->cont_ = cont_;
 974         second_->call( second_, evalState, val, traceLoc_ );
 975 }
 976
 977 Kernel::ContRef
 978 Kernel::ComposedFunctionCall_cont::up( ) const
 979 {
 980         return cont_;
 981 }
 982
 983 RefCountPtr< const char >
 984 Kernel::ComposedFunctionCall_cont::description( ) const
 985 {
 986         return strrefdup( "composed function's second application" );
 987 }
 988
 989 void
 990 Kernel::ComposedFunctionCall_cont::gcMark( Kernel::GCMarkedSet & marked )
 991 {
 992         const_cast< Lang::Function * >( second_.getPtr( ) )->gcMark( marked );
 993         dyn_->gcMark( marked );
 994         cont_->gcMark( marked );
 995 }
 996
 997
 998 Kernel::ForceFunctionAndCall_2_args_cont::ForceFunctionAndCall_2_args_cont( const Kernel::VariableHandle & arg1, const Kernel::VariableHandle & arg2, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
 999         : Kernel::Continuation( callLoc ), arg1_( arg1 ), arg2_( arg2 ), dyn_( dyn ), cont_( cont )
1000 { }
1001
1002 Kernel::ForceFunctionAndCall_2_args_cont::~ForceFunctionAndCall_2_args_cont( )
1003 { }
1004
1005 void
1006 Kernel::ForceFunctionAndCall_2_args_cont::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
1007 {
1008         evalState->dyn_ = dyn_;
1009         evalState->cont_ = cont_;
1010         typedef const Lang::Function ArgType;
1011         RefCountPtr< ArgType > fun( Helpers::down_cast_ContinuationArgument< ArgType >( val, this ) );
1012         fun->call( fun, evalState, arg1_, arg2_, traceLoc_ );
1013 }
1014
1015 Kernel::ContRef
1016 Kernel::ForceFunctionAndCall_2_args_cont::up( ) const
1017 {
1018         return cont_;
1019 }
1020
1021 RefCountPtr< const char >
1022 Kernel::ForceFunctionAndCall_2_args_cont::description( ) const
1023 {
1024         return strrefdup( "call function with two values" );
1025 }
1026
1027 void
1028 Kernel::ForceFunctionAndCall_2_args_cont::gcMark( Kernel::GCMarkedSet & marked )
1029 {
1030         arg1_->gcMark( marked );
1031         arg2_->gcMark( marked );
1032         dyn_->gcMark( marked );
1033         cont_->gcMark( marked );
1034 }
1035
1036
1037 Kernel::RelaxContinuation::RelaxContinuation( Kernel::ContRef & cont )
1038         : Kernel::Continuation( cont->traceLoc( ) ), cont_( cont )
1039 { }
1040
1041 Kernel::RelaxContinuation::~RelaxContinuation( )
1042 { }
1043
1044 void
1045 Kernel::RelaxContinuation::takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
1046 {
1047         evalState->cont_ = cont_;
1048         Helpers::relax( val, evalState );
1049 }
1050
1051 Kernel::ContRef
1052 Kernel::RelaxContinuation::up( ) const
1053 {
1054         return cont_;
1055 }
1056
1057 RefCountPtr< const char >
1058 Kernel::RelaxContinuation::description( ) const
1059 {
1060         return strrefdup( "relax" );
1061 }
1062
1063 void
1064 Kernel::RelaxContinuation::gcMark( Kernel::GCMarkedSet & marked )
1065 {
1066         cont_->gcMark( marked );
1067 }