source/astfun.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, 2014 Henrik Tidefelt
  17  */
  18
  19 #include "Shapes_Helpers_decls.h"
  20
  21 #include "astfun.h"
  22 #include "shapesexceptions.h"
  23 #include "shapescore.h"
  24 #include "consts.h"
  25 #include "globals.h"
  26 #include "continuations.h"
  27 #include "astvar.h"
  28 #include "astvalues.h"
  29 #include "texlabelmanager.h"
  30
  31 #include <sstream>
  32
  33 using namespace Shapes;
  34 using namespace std;
  35
  36
  37 Kernel::Formals::Formals( )
  38         : loc_( Ast::THE_UNKNOWN_LOCATION ),
  39                 seenDefault_( false ),
  40                 argumentIdentifiers_( new Ast::IdentifierTree( NULL, false ) ),
  41                 argumentOrder_( new std::map< const char *, size_t, charPtrLess > ),
  42                 sink_( NULL ),
  43                 stateIdentifiers_( new Ast::IdentifierTree( NULL, false ) ),
  44                 stateOrder_( new std::map< const char *, size_t, charPtrLess > )
  45 { }
  46
  47 Kernel::Formals::Formals( size_t numberOfDummyDefaultExprs )
  48         : loc_( Ast::THE_UNKNOWN_LOCATION ),
  49                 seenDefault_( false ),
  50                 argumentIdentifiers_( new Ast::IdentifierTree( NULL, false ) ),
  51                 argumentOrder_( new std::map< const char *, size_t, charPtrLess > ),
  52                 sink_( NULL ),
  53                 stateIdentifiers_( new Ast::IdentifierTree( NULL, false ) ),
  54                 stateOrder_( new std::map< const char *, size_t, charPtrLess > )
  55 {
  56         // Pushing null expressions is just a way of specifying how many non-sink arguments there are.
  57         for( size_t i = 0; i < numberOfDummyDefaultExprs; ++i )
  58                 {
  59                         defaultExprs_.push_back( NULL );
  60                 }
  61 }
  62
  63 Kernel::Formals::~Formals( )
  64 {
  65         delete argumentIdentifiers_;
  66         delete argumentOrder_;
  67         delete stateIdentifiers_;
  68         delete stateOrder_;
  69         if( sink_ != NULL )
  70                 {
  71                         delete sink_;
  72                 }
  73 }
  74
  75 void
  76 Kernel::Formals::setLoc( const Ast::SourceLocation & loc )
  77 {
  78         loc_ = loc;
  79 }
  80
  81 bool
  82 Kernel::Formals::appendArgumentFormal( const Ast::PlacedIdentifier & id )
  83 {
  84         size_t pos = argumentIdentifiers_->size( );
  85         if( ! argumentIdentifiers_->insert( id, loc_ ) ) /* The source location given here is more or less a dummy, it should never be needed. */
  86                 return false;
  87         argumentOrder_->insert( std::pair< const char *, size_t >( id.simpleId( ), pos ) );
  88         return true;
  89 }
  90
  91 bool
  92 Kernel::Formals::appendStateFormal( const Ast::PlacedIdentifier & id )
  93 {
  94         size_t pos = stateIdentifiers_->size( );
  95         if( ! stateIdentifiers_->insert( id, loc_ ) ) /* The source location given here is more or less a dummy, it should never be needed. */
  96                 return false;
  97         stateOrder_->insert( std::pair< const char *, size_t >( id.simpleId( ), pos ) );
  98         return true;
  99 }
 100
 101 void
 102 Kernel::Formals::push_exprs( Ast::ArgListExprs * args ) const
 103 {
 104         typedef typeof defaultExprs_ ListType;
 105         for( ListType::const_iterator i = defaultExprs_.begin( ); i != defaultExprs_.end( ); ++i )
 106                 {
 107                         if( *i != 0 )
 108                                 {
 109                                         args->orderedExprs_->push_back( *i );
 110                                 }
 111                 }
 112 }
 113
 114 Kernel::EvaluatedFormals *
 115 Kernel::Formals::newEvaluatedFormals( Kernel::Arguments & args ) const
 116 {
 117         size_t pos = 0;
 118         return newEvaluatedFormals( args, & pos );
 119 }
 120
 121 Kernel::EvaluatedFormals *
 122 Kernel::Formals::newEvaluatedFormals( Kernel::Arguments & args, size_t * pos ) const
 123 {
 124         Kernel::EvaluatedFormals * res = new Kernel::EvaluatedFormals( const_cast< Kernel::Formals * >( this ) );
 125         res->isSink_ = false; // The formals created here belong to user functions, which are exactly those which are not sinks.
 126
 127         res->defaults_.reserve( defaultExprs_.size( ) );
 128         res->locations_.reserve( defaultExprs_.size( ) );
 129
 130         typedef typeof defaultExprs_ ListType;
 131         for( ListType::const_iterator i = defaultExprs_.begin( ); i != defaultExprs_.end( ); ++i )
 132                 {
 133                         if( *i != 0 )
 134                                 {
 135                                         res->defaults_.push_back( args.getHandle( *pos ) );
 136                                         res->locations_.push_back( args.getNode( *pos ) );
 137                                         ++(*pos);
 138                                 }
 139                         else
 140                                 {
 141                                         res->defaults_.push_back( Kernel::THE_SLOT_VARIABLE );
 142                                         res->locations_.push_back( 0 );                                                                                                                  // I really hope this is never dereferenced!
 143                                 }
 144                 }
 145
 146         return res;
 147 }
 148
 149 std::vector< bool > *
 150 Kernel::Formals::newArgListForcePos( const Ast::ArgListExprs * argList ) const
 151 {
 152         /* Here, we use the knowledge that ordered arguments are evaluated backwards, and named arguments
 153          * in the natural order (the lexiographic order of std::map).
 154          */
 155
 156         std::vector< bool > * res = new std::vector< bool >;
 157         res->resize( argList->orderedExprs_->size( ) );
 158         res->reserve( argList->orderedExprs_->size( ) + argList->namedExprs_->size( ) );
 159
 160                 if( ! argList->orderedExprs_->empty( ) )
 161                         {
 162                                 typedef typeof forcePos_ SrcType;
 163                                 SrcType::const_iterator src = forcePos_.begin( );
 164                                 for( size_t arg = argList->orderedExprs_->size( ) - 1; ; --arg, ++src )
 165                                         {
 166                                                 (*res)[ arg ] = *src;
 167                                                 if( arg == 0 )
 168                                                         {
 169                                                                 break;
 170                                                         }
 171                                         }
 172                         }
 173
 174         {
 175                 typedef typeof *argList->namedExprs_ MapType;
 176                 MapType::const_iterator end = argList->namedExprs_->end( );
 177                 for( MapType::const_iterator arg = argList->namedExprs_->begin( ); arg != end; ++arg )
 178                         {
 179                                 res->push_back( forcePos_[ (*argumentOrder_)[ arg->first ] ] );
 180                         }
 181         }
 182
 183         return res;
 184 }
 185
 186 std::vector< bool > *
 187 Kernel::Formals::newArgListForcePos( const Ast::ArgListExprs * argList, const Kernel::Arguments & curryArgs ) const
 188 {
 189         /* Compare with the non-curry version!
 190          */
 191
 192         std::vector< bool > * res = new std::vector< bool >;
 193         res->resize( argList->orderedExprs_->size( ) );
 194         res->reserve( argList->orderedExprs_->size( ) + argList->namedExprs_->size( ) );
 195
 196         if( ! argList->orderedExprs_->empty( ) )
 197                 {
 198                         typedef typeof forcePos_ SrcType;
 199                         SrcType::const_iterator src = forcePos_.begin( );
 200                         size_t curryPos = 0;
 201                         while( curryPos < curryArgs.size( ) &&
 202                                                  ! curryArgs.isSlot( curryPos ) )
 203                                 {
 204                                         ++src;
 205                                         ++curryPos;
 206                                 }
 207                         for( size_t arg = argList->orderedExprs_->size( ) - 1; ; --arg )
 208                                 {
 209                                         (*res)[ arg ] = *src;
 210                                         if( arg == 0 )
 211                                                 {
 212                                                         break;
 213                                                 }
 214                                         ++src;
 215                                         ++curryPos;
 216                                         while( curryPos < curryArgs.size( ) &&
 217                                                                  ! curryArgs.isSlot( curryPos ) )
 218                                                 {
 219                                                         ++src;
 220                                                         ++curryPos;
 221                                                 }
 222                                 }
 223                 }
 224
 225         {
 226                 typedef typeof *argList->namedExprs_ MapType;
 227                 MapType::const_iterator end = argList->namedExprs_->end( );
 228                 for( MapType::const_iterator arg = argList->namedExprs_->begin( ); arg != end; ++arg )
 229                         {
 230                                 res->push_back( forcePos_[ (*argumentOrder_)[ arg->first ] ] );
 231                         }
 232         }
 233
 234         return res;
 235 }
 236
 237 const Ast::SourceLocation &
 238 Kernel::Formals::loc( ) const
 239 {
 240         return loc_;
 241 }
 242
 243
 244
 245 Ast::ArgListExprs::ConstIterator::ConstIterator( std::list< Ast::Expression * >::const_reverse_iterator i1, std::map< const char *, Ast::Expression *, charPtrLess >::const_iterator i2, const size_t & index )
 246         : i1_( i1 ), i2_( i2 ), index_( index )
 247 { }
 248
 249 Ast::ArgListExprs::ConstIterator::ConstIterator( const Ast::ArgListExprs::ConstIterator & orig )
 250         : i1_( orig.i1_ ), i2_( orig.i2_ ), index_( orig.index_ )
 251 { }
 252
 253 Ast::ArgListExprs::ArgListExprs( bool exprOwner )
 254         : exprOwner_( exprOwner ), orderedExprs_( new std::list< Ast::Expression * > ), namedExprs_( new std::map< const char *, Ast::Expression *, charPtrLess > ),
 255                 orderedStates_( new std::list< Ast::StateReference * > ), namedStates_( new std::map< const char *, Ast::StateReference *, charPtrLess > )
 256 {
 257         //      if( exprOwner_ )
 258         //              {
 259         //                      throw Exceptions::InternalError( strrefdup( "Ast::ArgListExprs( bool _exprOwner ) can only be called with false." ) );
 260         //              }
 261 }
 262
 263 Ast::ArgListExprs::ArgListExprs( std::list< Ast::Expression * > * orderedExprs, std::map< const char *, Ast::Expression *, charPtrLess > * namedExprs, std::list< Ast::StateReference * > * orderedStates, std::map< const char *, Ast::StateReference *, charPtrLess > * namedStates )
 264         : exprOwner_( true ), orderedExprs_( orderedExprs ), namedExprs_( namedExprs ), orderedStates_( orderedStates ), namedStates_( namedStates )
 265 { }
 266
 267 Ast::ArgListExprs::~ArgListExprs( )
 268 {
 269         {
 270                 if( exprOwner_ )
 271                         {
 272                                 typedef list< Ast::Expression * >::iterator I;
 273                                 for( I i = orderedExprs_->begin( ); i != orderedExprs_->end( ); ++i )
 274                                         {
 275                                                 delete *i;
 276                                         }
 277                         }
 278                 delete orderedExprs_;
 279         }
 280
 281         {
 282                 if( exprOwner_ )
 283                         {
 284                                 typedef std::map< const char *, Ast::Expression *, charPtrLess >::const_iterator I;
 285                                 for( I i = namedExprs_->begin( ); i != namedExprs_->end( ); ++i )
 286                                         {
 287                                                 delete i->first;
 288                                                 delete i->second;
 289                                         }
 290                         }
 291                 delete namedExprs_;
 292         }
 293
 294         {
 295                 if( exprOwner_ )
 296                         {
 297                                 typedef std::list< Ast::StateReference * >::iterator I;
 298                                 for( I i = orderedStates_->begin( ); i != orderedStates_->end( ); ++i )
 299                                         {
 300                                                 delete *i;
 301                                         }
 302                         }
 303                 delete orderedStates_;
 304         }
 305
 306         {
 307                 if( exprOwner_ )
 308                         {
 309                                 typedef std::map< const char *, Ast::StateReference *, charPtrLess >::const_iterator I;
 310                                 for( I i = namedStates_->begin( ); i != namedStates_->end( ); ++i )
 311                                         {
 312                                                 delete i->first;
 313                                                 delete i->second;
 314                                         }
 315                         }
 316                 delete namedStates_;
 317         }
 318 }
 319
 320 Ast::ArgListExprs::ArgListExprs( size_t numberOfOrderedDummyExprs )
 321         : exprOwner_( true ), orderedExprs_( new std::list< Ast::Expression * > ), namedExprs_( new std::map< const char *, Ast::Expression *, charPtrLess > ), orderedStates_( new typeof *orderedStates_ ), namedStates_( new typeof *namedStates_ )
 322 {
 323         for( size_t i = 0; i < numberOfOrderedDummyExprs; ++i )
 324                 {
 325                         orderedExprs_->push_back( new Ast::DummyExpression );
 326                 }
 327 }
 328
 329
 330 void
 331 Ast::ArgListExprs::evaluate( const RefCountPtr< const Kernel::CallContInfo > & info, const Ast::ArgListExprs::ConstIterator & pos, const RefCountPtr< const Lang::SingleList > & vals, Kernel::EvalState * evalState ) const
 332 {
 333         std::list< Ast::Expression * >::const_reverse_iterator i1end = orderedExprs_->rend( );
 334
 335         if( pos.i1_ == i1end &&
 336                         pos.i2_ == namedExprs_->end( ) )
 337                 {
 338                         evalState->cont_ = info->cont_;
 339                         info->cont_->takeValue( vals, evalState );
 340                         return;
 341                 }
 342
 343         if( pos.i1_ != i1end )
 344                 {
 345                         /* Note that it is necessary that the evaluation of expressions with free states is not delayed.
 346                          * If it would, it would be very strange for the calling function if a passed state would change
 347                          * value in response to the accessing of a formal parameter.
 348                          */
 349                         if( info->force( pos.index_ ) || (*(pos.i1_))->immediate_ )
 350                                 {
 351                                         typedef typeof const_cast< Ast::ArgListExprs::ConstIterator & >( pos ).i1_ Iterator;
 352                                         Iterator next = pos.i1_;
 353                                         ++next;
 354                                         evalState->expr_ = *(pos.i1_);
 355                                         evalState->env_ = info->env_;
 356                                         evalState->dyn_ = info->dyn_;
 357                                         evalState->cont_ = Kernel::ContRef( new Kernel::CallCont_n( evalState->expr_->loc( ),
 358                                                                                                                                                                                                                                                                                         info,
 359                                                                                                                                                                                                                                                                                         Ast::ArgListExprs::ConstIterator( next, pos.i2_, pos.index_ + 1 ),
 360                                                                                                                                                                                                                                                                                         vals ) );
 361                                         return;
 362                                 }
 363                         else
 364                                 {
 365                                         /* Delay evaluation of this argument by just putting a thunk in the list.
 366                                          */
 367                                         typedef typeof const_cast< Ast::ArgListExprs::ConstIterator & >( pos ).i1_ Iterator;
 368                                         Iterator next = pos.i1_;
 369                                         ++next;
 370                                         evaluate( info,
 371                                                                                 Ast::ArgListExprs::ConstIterator( next, pos.i2_, pos.index_ + 1 ),
 372                                                                                 RefCountPtr< const Lang::SingleListPair >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( new Kernel::Thunk( info->env_, info->dyn_, *pos.i1_ ) ) ),
 373                                                                                                                                                                                                                                                                                                                                                                                          vals ) ),
 374                                                                                 evalState );
 375                                         return; /* It is not really important that the above compiles to a tail call.   Hopefully, it does, but otherwise it is easy to see that the chain of recursive calls to this function
 376                                                                                 * will always completes without evaluation of expressions. */
 377                                 }
 378                 }
 379         else
 380                 {
 381                         if( info->force( pos.index_ ) || pos.i2_->second->immediate_ )
 382                                 {
 383                                         typedef typeof const_cast< Ast::ArgListExprs::ConstIterator & >( pos ).i2_ Iterator;
 384                                         Iterator next = pos.i2_;
 385                                         ++next;
 386                                         evalState->expr_ = pos.i2_->second;
 387                                         evalState->env_ = info->env_;
 388                                         evalState->dyn_ = info->dyn_;
 389                                         evalState->cont_ = Kernel::ContRef( new Kernel::CallCont_n( evalState->expr_->loc( ),
 390                                                                                                                                                                                                                                                                                         info,
 391                                                                                                                                                                                                                                                                                         Ast::ArgListExprs::ConstIterator( pos.i1_, next, pos.index_ + 1 ),
 392                                                                                                                                                                                                                                                                                         vals ) );
 393                                         return;
 394                                 }
 395                         else
 396                                 {
 397                                         /* Delay evaluation of this argument by just putting a thunk in the list.
 398                                          */
 399                                         typedef typeof const_cast< Ast::ArgListExprs::ConstIterator & >( pos ).i2_ Iterator;
 400                                         Iterator next = pos.i2_;
 401                                         ++next;
 402                                         evaluate( info,
 403                                                                                 Ast::ArgListExprs::ConstIterator( pos.i1_, next, pos.index_ + 1 ),
 404                                                                                 RefCountPtr< const Lang::SingleListPair >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( new Kernel::Thunk( info->env_, info->dyn_, pos.i2_->second ) ) ),
 405                                                                                                                                                                                                                                                                                                                                                                                          vals ) ),
 406                                                                                 evalState );
 407                                         return; /* It is not really important that the above compiles to a tail call.   Hopefully, it does, but otherwise it is easy to see that the chain of recursive calls to this function
 408                                                                                 * will always complete without evaluation of expressions. */
 409                                 }
 410                 }
 411 }
 412
 413 void
 414 Ast::ArgListExprs::bind( Kernel::Arguments * dst, RefCountPtr< const Lang::SingleList > vals, Kernel::PassedEnv env, Kernel::PassedDyn dyn ) const
 415 {
 416         typedef const Lang::SingleListPair ConsType;
 417
 418         /* Note that the arguments are bound in backwards-order, since that is how the values are accessed.
 419          */
 420
 421         {
 422                 typedef std::map< const char *, Ast::Expression *, charPtrLess >::const_reverse_iterator I;
 423                 I i = namedExprs_->rbegin( );
 424                 I end = namedExprs_->rend( );
 425                 for( ; i != end; ++i )
 426                         {
 427                                 RefCountPtr< ConsType > lst = vals.down_cast< ConsType >( );
 428                                 if( lst == NullPtr< ConsType >( ) )
 429                                         {
 430                                                 throw Exceptions::InternalError( strrefdup( "Out of argument values when binding application." ) );
 431                                         }
 432                                 dst->addNamedArgument( i->first, lst->car_, i->second );
 433                                 vals = lst->cdr_;
 434                         }
 435         }
 436
 437         {
 438                 typedef list< Ast::Expression * >::const_iterator I;
 439                 I i = orderedExprs_->begin( );
 440                 I end = orderedExprs_->end( );
 441                 for( ; i != end; ++i )
 442                         {
 443                                 RefCountPtr< ConsType > lst = vals.down_cast< ConsType >( );
 444                                 if( lst == NullPtr< ConsType >( ) )
 445                                         {
 446                                                 throw Exceptions::InternalError( strrefdup( "Out of argument values when binding application." ) );
 447                                         }
 448                                 dst->addOrderedArgument( lst->car_, *i );
 449                                 vals = lst->cdr_;
 450                         }
 451         }
 452
 453         /* Here, it could/should be verified that vals is null. However, it only isn't in case of an internal error...
 454          */
 455
 456         /* Next, we turn to the states. The states need no evaluation, as they are always passed by reference.
 457          */
 458
 459         {
 460                 typedef std::map< const char *, Ast::StateReference *, charPtrLess >::const_iterator I;
 461                 I i = namedStates_->begin( );
 462                 I end = namedStates_->end( );
 463                 for( ; i != end; ++i )
 464                         {
 465                                 dst->addNamedState( i->first, i->second->getHandle( env, dyn ) , i->second );
 466                         }
 467         }
 468
 469         {
 470                 typedef list< Ast::StateReference * >::const_iterator I;
 471                 I i = orderedStates_->begin( );
 472                 I end = orderedStates_->end( );
 473                 for( ; i != end; ++i )
 474                         {
 475                                 dst->addOrderedState( (*i)->getHandle( env, dyn ), *i );
 476                         }
 477         }
 478
 479 }
 480
 481
 482 Kernel::VariableHandle
 483 Ast::ArgListExprs::findNamed( RefCountPtr< const Lang::SingleList > vals, const char * name ) const
 484 {
 485         /* This function is called when a Lang::Structure is asked for a field by name.
 486          * This is reflected in the generated error in case the name is not found.
 487          */
 488
 489         typedef const Lang::SingleListPair ConsType;
 490
 491         /* Note that the arguments are bound in backwards-order, since that is how the values are accessed.
 492          */
 493
 494         typedef std::map< const char *, Ast::Expression *, charPtrLess >::const_reverse_iterator I;
 495         I i = namedExprs_->rbegin( );
 496         I end = namedExprs_->rend( );
 497         for( ; i != end; ++i )
 498                 {
 499                         RefCountPtr< ConsType > lst = vals.down_cast< ConsType >( );
 500                         if( lst == NullPtr< ConsType >( ) )
 501                                 {
 502                                         throw Exceptions::InternalError( strrefdup( "Out of argument values when searching fields." ) );
 503                                 }
 504                         if( strcmp( i->first, name ) == 0 )
 505                                 {
 506                                         return lst->car_;
 507                                 }
 508                         vals = lst->cdr_;
 509                 }
 510
 511         throw Exceptions::NonExistentMember( strrefdup( "< user union >" ), name );
 512 }
 513
 514 Kernel::VariableHandle
 515 Ast::ArgListExprs::getOrdered( RefCountPtr< const Lang::SingleList > vals, size_t pos ) const
 516 {
 517         /* This function is called when a Lang::Structure is asked for a field by position.
 518          * This is reflected in the generated error in case the position is not found.
 519          */
 520
 521         typedef const Lang::SingleListPair ConsType;
 522
 523         /* Note that the arguments are bound in backwards-order, since that is how the values are accessed.
 524          */
 525
 526         size_t i = 0;
 527         while( true )
 528                 {
 529                         RefCountPtr< ConsType > lst = vals.down_cast< ConsType >( );
 530                         if( lst == NullPtr< ConsType >( ) )
 531                                 {
 532                                         break;
 533                                 }
 534                         if( i == pos )
 535                                 {
 536                                         return lst->car_;
 537                                 }
 538                         vals = lst->cdr_;
 539                         ++i;
 540                 }
 541
 542         throw Exceptions::NonExistentPosition( pos, i - 1 );
 543 }
 544
 545 void
 546 Ast::ArgListExprs::analyze( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 547 {
 548         parent_ = parent;
 549
 550         RefCountPtr< Ast::StateIDSet > passedStates( new Ast::StateIDSet );
 551
 552         /* First traverse state arguments, so that we know which states that must not appear in the value arguments.
 553          */
 554         {
 555                 typedef typeof *orderedStates_ ListType;
 556                 for( ListType::iterator i = orderedStates_->begin( ); i != orderedStates_->end( ); ++i )
 557                         {
 558                                 (*i)->analyze( parent_, env, passedStates.getPtr( ) );
 559                         }
 560         }
 561         {
 562                 typedef typeof *namedStates_ ListType;
 563                 for( ListType::iterator i = namedStates_->begin( ); i != namedStates_->end( ); ++i )
 564                         {
 565                                 i->second->analyze( parent_, env, passedStates.getPtr( ) );
 566                         }
 567         }
 568         if( passedStates->size( ) < orderedStates_->size( ) + namedStates_->size( ) )
 569                 {
 570                         Ast::theAnalysisErrorsList.push_back( new Exceptions::RepeatedStateArgument( parent_->loc( ), passedStates ) );
 571                 }
 572
 573         /* Traverse children
 574          */
 575         {
 576                 typedef typeof *orderedExprs_ ListType;
 577                 for( ListType::iterator i = orderedExprs_->begin( ); i != orderedExprs_->end( ); ++i )
 578                         {
 579                                 if( (*i)->immediate_ )
 580                                         {
 581                                                 (*i)->analyze( parent_, env, freeStatesDst );
 582                                         }
 583                                 else
 584                                         {
 585                                                 Ast::StateIDSet freeStates;
 586                                                 (*i)->analyze( parent_, env, & freeStates );
 587                                                 for( Ast::StateIDSet::const_iterator j = freeStates.begin( ); j != freeStates.end( ); ++j )
 588                                                         {
 589                                                                 if( passedStates->find( *j ) != passedStates->end( ) )
 590                                                                         {
 591                                                                                 Ast::theAnalysisErrorsList.push_back( new Exceptions::FreeStateIsAlsoPassed( (*i)->loc( ), *j ) );
 592                                                                         }
 593                                                                 freeStatesDst->insert( *j );
 594                                                         }
 595                                         }
 596                         }
 597         }
 598         {
 599                 typedef typeof *namedExprs_ ListType;
 600                 for( ListType::iterator i = namedExprs_->begin( ); i != namedExprs_->end( ); ++i )
 601                         {
 602                                 if( i->second->immediate_ )
 603                                         {
 604                                                 i->second->analyze( parent_, env, freeStatesDst );
 605                                         }
 606                                 else
 607                                         {
 608                                                 Ast::StateIDSet freeStates;
 609                                                 i->second->analyze( parent_, env, & freeStates );
 610                                                 for( Ast::StateIDSet::const_iterator j = freeStates.begin( ); j != freeStates.end( ); ++j )
 611                                                         {
 612                                                                 if( passedStates->find( *j ) != passedStates->end( ) )
 613                                                                         {
 614                                                                                 Ast::theAnalysisErrorsList.push_back( new Exceptions::FreeStateIsAlsoPassed( i->second->loc( ), *j ) );
 615                                                                         }
 616                                                                 freeStatesDst->insert( *j );
 617                                                         }
 618                                         }
 619                         }
 620         }
 621
 622         {
 623                 for( Ast::StateIDSet::const_iterator i = passedStates->begin( ); i != passedStates->end( ); ++i )
 624                         {
 625                                 freeStatesDst->insert( *i );
 626                         }
 627         }
 628 }
 629
 630 Ast::ArgListExprs::ConstIterator
 631 Ast::ArgListExprs::begin( ) const
 632 {
 633         return Ast::ArgListExprs::ConstIterator( orderedExprs_->rbegin( ), namedExprs_->begin( ), 0 );
 634 }
 635
 636
 637 Ast::FunctionFunction::FunctionFunction( const Ast::SourceLocation & loc, const Kernel::Formals * formals, Ast::Expression * body, const Ast::FunctionMode & functionMode )
 638         : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( "< function construction >" ), false ) ), loc_( loc ), formals_( formals ), body_( body ), functionMode_( functionMode )
 639 { }
 640
 641 Ast::FunctionFunction::~FunctionFunction( )
 642 {
 643         delete formals_;
 644         delete body_;
 645 }
 646
 647 void
 648 Ast::FunctionFunction::push_exprs( Ast::ArgListExprs * args ) const
 649 {
 650         formals_->push_exprs( args );
 651 }
 652
 653 void
 654 Ast::FunctionFunction::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * parentEnv, Ast::StateIDSet * freeStatesDst )
 655 {
 656         Ast::AnalysisEnvironment * env( new Ast::AnalysisEnvironment( Ast::theAnalysisEnvironmentList, parentEnv, formals_->argumentIdentifiers_, formals_->stateIdentifiers_ ) );
 657         env->activateFunctionBoundary( );
 658
 659         /* We know that the body does not access states outside the function's scope, so we can simply
 660          * leave freeStatesDst without change.
 661          */
 662         Ast::StateIDSet freeStates;
 663         body_->analyze( parent, env, & freeStates );
 664 }
 665
 666 void
 667 Ast::FunctionFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 668 {
 669         Kernel::ContRef cont = evalState->cont_;
 670         cont->takeValue( Kernel::ValueRef( new Lang::UserFunction( formals_->newEvaluatedFormals( args ),
 671                                                                                                                                                                                                                                                  body_, evalState->env_, functionMode_ ) ),
 672                                                                          evalState );
 673 }
 674
 675
 676 Kernel::CallCont_last::CallCont_last( const RefCountPtr< const Lang::Function > & fun, const Ast::ArgListExprs * argList, bool curry, Kernel::StateHandle mutatorSelf, const Kernel::PassedEnv & env, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
 677         : Kernel::Continuation( callLoc ), fun_( fun ), argList_( argList ), curry_( curry ), mutatorSelf_( mutatorSelf ), env_( env ), dyn_( dyn ), cont_( cont )
 678 { }
 679
 680 Kernel::CallCont_last::~CallCont_last( )
 681 { }
 682
 683 void
 684 Kernel::CallCont_last::takeValue( const RefCountPtr< const Lang::Value > & valsUntyped, Kernel::EvalState * evalState, bool dummy ) const
 685 {
 686         typedef const Lang::SingleList ArgType;
 687         RefCountPtr< ArgType > vals = Helpers::down_cast< ArgType >( valsUntyped, "< Internal error situation in CallCont_last >" );
 688
 689         Kernel::Arguments args = fun_->newCurriedArguments( );
 690         argList_->bind( & args, vals, env_, dyn_ );
 691         if( mutatorSelf_ != 0 )
 692                 {
 693                         args.setMutatorSelf( mutatorSelf_ );
 694                 }
 695
 696         if( curry_ )
 697                 {
 698                         evalState->cont_ = cont_;
 699                         cont_->takeValue( Kernel::ValueRef( new Lang::CuteFunction( fun_, args ) ), evalState );
 700                 }
 701         else
 702                 {
 703                         evalState->env_ = env_; /* This matters only when the function being called is FunctionFunction! */
 704                         evalState->dyn_ = dyn_;
 705                         evalState->cont_ = cont_;
 706                         fun_->call( evalState, args, traceLoc_ );
 707                 }
 708 }
 709
 710 Kernel::ContRef
 711 Kernel::CallCont_last::up( ) const
 712 {
 713         return cont_;
 714 }
 715
 716 RefCountPtr< const char >
 717 Kernel::CallCont_last::description( ) const
 718 {
 719         return strrefdup( "function call's application" );
 720 }
 721
 722 void
 723 Kernel::CallCont_last::gcMark( Kernel::GCMarkedSet & marked )
 724 {
 725         const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
 726         dyn_->gcMark( marked );
 727         cont_->gcMark( marked );
 728 }
 729
 730 Kernel::CallContInfo::CallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, std::vector< bool > * forcePos )
 731         : forcePos_( forcePos ), forceAll_( false ), argList_( argList ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ )
 732 { }
 733
 734 Kernel::CallContInfo::CallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, bool forceAll )
 735         : forcePos_( 0 ), forceAll_( forceAll ), argList_( argList ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ )
 736 { }
 737
 738 Kernel::CallContInfo::~CallContInfo( )
 739 {
 740         if( forcePos_ != 0 )
 741                 {
 742                         delete forcePos_;
 743                 }
 744 }
 745
 746 bool
 747 Kernel::CallContInfo::force( const size_t & pos ) const
 748 {
 749         if( forcePos_ != 0 )
 750                 {
 751                         return (*forcePos_)[ pos ];
 752                 }
 753         return forceAll_;
 754 }
 755
 756 bool
 757 Kernel::CallContInfo::isSelective( ) const
 758 {
 759         return forcePos_ != 0;
 760 }
 761
 762 void
 763 Kernel::CallContInfo::gcMark( Kernel::GCMarkedSet & marked )
 764 {
 765         env_->gcMark( marked );
 766         dyn_->gcMark( marked );
 767         cont_->gcMark( marked );
 768 }
 769
 770 Kernel::CallCont_n::CallCont_n( const Ast::SourceLocation & traceLoc, const RefCountPtr< const Kernel::CallContInfo > & info, const Ast::ArgListExprs::ConstIterator & pos, RefCountPtr< const Lang::SingleList > vals )
 771         : Kernel::Continuation( traceLoc ), info_( info ), pos_( pos ), vals_( vals )
 772 { }
 773
 774 Kernel::CallCont_n::~CallCont_n( )
 775 { }
 776
 777 void
 778 Kernel::CallCont_n::takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
 779 {
 780         /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
 781          * However, this continuation takes handles anyway, since handles is what goes into the argument list.
 782          */
 783
 784         if( val->isThunk( ) )
 785                 {
 786                         val->force( val, evalState );
 787                         return;
 788                 }
 789         if( val == Kernel::THE_SLOT_VARIABLE )
 790                 {
 791                         /* If we don't detect this, the error messages that will be printed later would be very confusing,
 792                          * saying that the argument is missing, when the problem is likely to be that some internal
 793                          * computation should result in THE_VOID_VARIABLE rather than THE_SLOT_VARIABLE.
 794                          */
 795                         throw Exceptions::InternalError( "An argument expression evaluated to THE_SLOT_VARIABLE." );
 796                 }
 797         info_->argList_->evaluate( info_,
 798                                                                                                                  pos_,
 799                                                                                                                  RefCountPtr< const Lang::SingleListPair >( new Lang::SingleListPair( val, vals_ ) ),
 800                                                                                                                  evalState );
 801 }
 802
 803 Kernel::ContRef
 804 Kernel::CallCont_n::up( ) const
 805 {
 806         return info_->cont_;
 807 }
 808
 809 RefCountPtr< const char >
 810 Kernel::CallCont_n::description( ) const
 811 {
 812         return strrefdup( "function call's argument" );
 813 }
 814
 815 void
 816 Kernel::CallCont_n::gcMark( Kernel::GCMarkedSet & marked )
 817 {
 818         const_cast< Kernel::CallContInfo * >( info_.getPtr( ) )->gcMark( marked );
 819         const_cast< Lang::SingleList * >( vals_.getPtr( ) )->gcMark( marked );
 820 }
 821
 822
 823 Kernel::CallCont_1::CallCont_1( const Ast::SourceLocation & traceLoc, const Ast::ArgListExprs * argList, bool curry, Kernel::StateHandle mutatorSelf, const Kernel::EvalState & evalState, const Ast::SourceLocation & callLoc )
 824         : Kernel::Continuation( traceLoc ), argList_( argList ), curry_( curry ), mutatorSelf_( mutatorSelf ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ ), callLoc_( callLoc )
 825 { }
 826
 827 Kernel::CallCont_1::~CallCont_1( )
 828 { }
 829
 830 void
 831 Kernel::CallCont_1::takeValue( const RefCountPtr< const Lang::Value > & funUntyped, Kernel::EvalState * evalState, bool dummy ) const
 832 {
 833         {
 834                 typedef const Lang::Function ArgType;
 835                 RefCountPtr< ArgType > fun = funUntyped.down_cast< const Lang::Function >( );
 836                 if( fun != NullPtr< ArgType >( ) )
 837                         {
 838                                 evalState->env_ = env_;
 839                                 evalState->dyn_ = dyn_;
 840                                 evalState->cont_ = Kernel::ContRef( new Kernel::CallCont_last( fun, argList_, curry_, mutatorSelf_, env_, dyn_, cont_, callLoc_ ) );
 841                                 argList_->evaluate( fun->newCallContInfo( argList_, *evalState ),
 842                                                                                                                 argList_->begin( ), Lang::THE_CONS_NULL,
 843                                                                                                                 evalState );
 844                                 return;
 845                         }
 846         }
 847         {
 848                 typedef const Lang::Transform2D ArgType;
 849                 ArgType * transformVal = dynamic_cast< ArgType * >( funUntyped.getPtr( ) );
 850                 if( transformVal != 0 )
 851                         {
 852                                 if( curry_ )
 853                                         {
 854                                                 throw Exceptions::MiscellaneousRequirement( strrefdup( "Don't Curry transform applications.     It's useless anyway!" ) );
 855                                         }
 856                                 if( argList_->orderedExprs_->size( ) != 1 )
 857                                         {
 858                                                 throw Exceptions::CoreArityMismatch( "<transform application>", 1, argList_->orderedExprs_->size( ) );
 859                                         }
 860                                 if( ! argList_->namedExprs_->empty( ) )
 861                                         {
 862                                                 throw Exceptions::CoreNoNamedFormals( "<transform application>" );
 863                                         }
 864                                 evalState->expr_ = argList_->orderedExprs_->front( );
 865                                 evalState->env_ = env_;
 866                                 evalState->dyn_ = dyn_;
 867                                 evalState->cont_ = Kernel::ContRef( new Kernel::Transform2DCont( *transformVal, cont_, callLoc_ ) );
 868                                 return;
 869                         }
 870         }
 871         {
 872                 typedef const Lang::Transform3D ArgType;
 873                 ArgType * transformVal = dynamic_cast< ArgType * >( funUntyped.getPtr( ) );
 874                 if( transformVal != 0 )
 875                         {
 876                                 if( curry_ )
 877                                         {
 878                                                 throw Exceptions::MiscellaneousRequirement( strrefdup( "Don't Curry transform applications.     It's useless anyway!" ) );
 879                                         }
 880                                 if( argList_->orderedExprs_->size( ) != 1 )
 881                                         {
 882                                                 throw Exceptions::CoreArityMismatch( "<transform application>", 1, argList_->orderedExprs_->size( ) );
 883                                         }
 884                                 if( ! argList_->namedExprs_->empty( ) )
 885                                         {
 886                                                 throw Exceptions::CoreNoNamedFormals( "<transform application>" );
 887                                         }
 888                                 evalState->expr_ = argList_->orderedExprs_->front( );
 889                                 evalState->env_ = env_;
 890                                 evalState->dyn_ = dyn_;
 891                                 evalState->cont_ = Kernel::ContRef( new Kernel::Transform3DCont( *transformVal, cont_, callLoc_ ) );
 892                                 return;
 893                         }
 894         }
 895
 896         {
 897                 typedef const Lang::ElementaryPath2D ArgType;
 898                 RefCountPtr< ArgType > path = NullPtr< ArgType >( );
 899                 try
 900                         {
 901                                 path = Helpers::elementaryPathCast2D( funUntyped, this );
 902                         }
 903                 catch( const Exceptions::ContinuationTypeMismatch & ball )
 904                         {
 905                                 goto nextType1;
 906                         }
 907
 908                 if( curry_ )
 909                         {
 910                                 throw Exceptions::MiscellaneousRequirement( strrefdup( "Don't Curry path point selection.       It's useless anyway!" ) );
 911                         }
 912                 if( argList_->orderedExprs_->size( ) != 1 )
 913                         {
 914                                 throw Exceptions::CoreArityMismatch( "<path point selection>", 1, argList_->orderedExprs_->size( ) );
 915                         }
 916                 if( ! argList_->namedExprs_->empty( ) )
 917                         {
 918                                 throw Exceptions::CoreNoNamedFormals( "<path point selection>" );
 919                         }
 920
 921                 evalState->expr_ = argList_->orderedExprs_->front( );
 922                 evalState->env_ = env_;
 923                 evalState->dyn_ = dyn_;
 924                 evalState->cont_ = Kernel::ContRef( new Kernel::PathApplication2DCont( path,
 925                                                                                                                                                                                                                                                                                                          cont_,
 926                                                                                                                                                                                                                                                                                                          callLoc_ ) );
 927                 return;
 928         }
 929  nextType1:
 930
 931         {
 932                 typedef const Lang::ElementaryPath3D ArgType;
 933                 RefCountPtr< ArgType > path = NullPtr< ArgType >( );
 934                 try
 935                         {
 936                                 path = Helpers::elementaryPathCast3D( funUntyped, this );
 937                         }
 938                 catch( const Exceptions::ContinuationTypeMismatch & ball )
 939                         {
 940                                 goto nextType2;
 941                         }
 942
 943                 if( curry_ )
 944                         {
 945                                 throw Exceptions::MiscellaneousRequirement( strrefdup( "Don't Curry path point selection.       It's useless anyway!" ) );
 946                         }
 947                 if( argList_->orderedExprs_->size( ) != 1 )
 948                         {
 949                                 throw Exceptions::CoreArityMismatch( "<path point selection>", 1, argList_->orderedExprs_->size( ) );
 950                         }
 951                 if( ! argList_->namedExprs_->empty( ) )
 952                         {
 953                                 throw Exceptions::CoreNoNamedFormals( "<path point selection>" );
 954                         }
 955
 956                 evalState->expr_ = argList_->orderedExprs_->front( );
 957                 evalState->env_ = env_;
 958                 evalState->dyn_ = dyn_;
 959                 evalState->cont_ = Kernel::ContRef( new Kernel::PathApplication3DCont( path,
 960                                                                                                                                                                                                                                                                                                          cont_,
 961                                                                                                                                                                                                                                                                                                          callLoc_ ) );
 962                 return;
 963         }
 964  nextType2:
 965
 966         throw Exceptions::TypeMismatch( traceLoc_,
 967                                                                                                                                         funUntyped->getTypeName( ),
 968                                                                                                                                         Helpers::typeSetString( Lang::Function::staticTypeName( ),
 969                                                                                                                                                                                                                                         Lang::Transform2D::staticTypeName( ),
 970                                                                                                                                                                                                                                         Lang::Transform3D::staticTypeName( ),
 971                                                                                                                                                                                                                                         Lang::ElementaryPath2D::staticTypeName( ),
 972                                                                                                                                                                                                                                         Lang::ElementaryPath3D::staticTypeName( ) ) );
 973 }
 974
 975 Kernel::ContRef
 976 Kernel::CallCont_1::up( ) const
 977 {
 978         return cont_;
 979 }
 980
 981 RefCountPtr< const char >
 982 Kernel::CallCont_1::description( ) const
 983 {
 984         return strrefdup( "function call's function" );
 985 }
 986
 987 void
 988 Kernel::CallCont_1::gcMark( Kernel::GCMarkedSet & marked )
 989 {
 990         dyn_->gcMark( marked );
 991         cont_->gcMark( marked );
 992 }
 993
 994
 995
 996 Ast::CallExpr::CallExpr( const Ast::SourceLocation & loc, Ast::Expression * funExpr, Ast::ArgListExprs * argList, bool curry )
 997         : Ast::Expression( loc ), curry_( curry ), constFun_( Kernel::THE_NO_FUNCTION ), mutatorSelf_( 0 ), funExpr_( funExpr ), argList_( argList )
 998 { }
 999
1000 Ast::CallExpr::CallExpr( const Ast::SourceLocation & loc, const RefCountPtr< const Lang::Function > & constFun, Ast::ArgListExprs * argList, bool curry )
1001         : Ast::Expression( loc ), curry_( curry ), constFun_( constFun ), mutatorSelf_( 0 ), funExpr_( 0 ), argList_( argList )
1002 { }
1003
1004 Ast::CallExpr::~CallExpr( )
1005 {
1006         if( funExpr_ != 0 )
1007                 {
1008                         delete funExpr_;
1009                 }
1010         if( mutatorSelf_ != 0 )
1011                 {
1012                         delete mutatorSelf_;
1013                 }
1014         delete argList_;
1015 }
1016
1017 void
1018 Ast::CallExpr::setMutatorSelf( Ast::StateReference * mutatorSelf )
1019 {
1020         mutatorSelf_ = mutatorSelf;
1021 }
1022
1023 void
1024 Ast::CallExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
1025 {
1026         if( mutatorSelf_ != 0 )
1027                 {
1028                         mutatorSelf_->analyze( this, env, freeStatesDst );
1029                 }
1030         if( funExpr_ != 0 )
1031                 {
1032                         funExpr_->analyze( this, env, freeStatesDst );
1033                 }
1034         else
1035                 {
1036                         const_cast< Lang::Function * >( constFun_.getPtr( ) )->analyze( this, env );
1037                 }
1038         argList_->analyze( this, env, freeStatesDst );
1039
1040         if( funExpr_ != 0 )
1041                 {
1042                         Ast::LexiographicVariable * var = dynamic_cast< Ast::LexiographicVariable * >( funExpr_ );
1043                         if( var != 0 &&
1044                                         var->scope_level( ) == 0 )
1045                                 {
1046                                         /* The callee is bound in the base environment. */
1047                                         if( strcmp( var->id( )->simpleId( ), Lang::TEX_SYNTAX_ID ) == 0 ) /* Assume there is only one namespace with a matching identifier to simplify the comparison. */
1048                                                 {
1049                                                         /* Someone is calling TeX.  If the argument is a string literal, it should be announced. */
1050                                                         if( argList_->orderedExprs_ != 0 && ! argList_->orderedExprs_->empty( ) )
1051                                                                 {
1052                                                                         /* If there are named arguments or more than one ordered argument, they are ignored; only the first ordered argument is checked. */
1053                                                                         Ast::Constant * carg = dynamic_cast< Ast::Constant * >( argList_->orderedExprs_->front( ) );
1054                                                                         if( carg != 0 )
1055                                                                                 {
1056                                                                                         try
1057                                                                                                 {
1058                                                                                                         typedef const Lang::String ArgType;
1059                                                                                                         RefCountPtr< ArgType > strArg = carg->val( )->tryVal< ArgType >( );
1060                                                                                                         Kernel::theTeXLabelManager.announce( std::string( strArg->val_.getPtr( ) ), carg->loc( ) );
1061                                                                                                 }
1062                                                                                         catch( const NonLocalExit::NotThisType & ball )
1063                                                                                                 {
1064                                                                                                         /* This is probably a type mismatch error, but we let the callee make the decision. */
1065                                                                                                 }
1066                                                                                 }
1067                                                                 }
1068                                                 }
1069                                 }
1070                 }
1071 }
1072
1073 void
1074 Ast::CallExpr::eval( Kernel::EvalState * evalState ) const
1075 {
1076         if( funExpr_ != 0 )
1077                 {
1078                         evalState->expr_ = funExpr_;
1079                         evalState->cont_ = Kernel::ContRef( new Kernel::CallCont_1( evalState->expr_->loc( ), argList_, curry_, mutatorSelf_ ? (mutatorSelf_->getHandle( evalState->env_, evalState->dyn_ )) : 0, *evalState, loc_ ) );
1080                 }
1081         else
1082                 {
1083                         evalState->cont_ = Kernel::ContRef( new Kernel::CallCont_last( constFun_, argList_, curry_, mutatorSelf_ ? (mutatorSelf_->getHandle( evalState->env_, evalState->dyn_ )) : 0, evalState->env_, evalState->dyn_, evalState->cont_, loc_ ) );
1084                         argList_->evaluate( constFun_->newCallContInfo( argList_, *evalState ),
1085                                                                                                         argList_->begin( ), Lang::THE_CONS_NULL,
1086                                                                                                         evalState );
1087                 }
1088 }
1089
1090 Kernel::UnionCont_last::UnionCont_last( const Ast::ArgListExprs * argList, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
1091         : Kernel::Continuation( callLoc ), argList_( argList ), cont_( cont )
1092 { }
1093
1094 Kernel::UnionCont_last::~UnionCont_last( )
1095 { }
1096
1097 void
1098 Kernel::UnionCont_last::takeValue( const RefCountPtr< const Lang::Value > & valsUntyped, Kernel::EvalState * evalState, bool dummy ) const
1099 {
1100         typedef const Lang::SingleList ArgType;
1101         RefCountPtr< ArgType > vals = Helpers::down_cast< ArgType >( valsUntyped, "< Internal error situation in UnionCont_last >" );
1102
1103         evalState->cont_ = cont_;
1104         cont_->takeValue( Kernel::ValueRef( new Lang::Structure( argList_, vals ) ),
1105                                                                                 evalState );
1106 }
1107
1108 Kernel::ContRef
1109 Kernel::UnionCont_last::up( ) const
1110 {
1111         return cont_;
1112 }
1113
1114 RefCountPtr< const char >
1115 Kernel::UnionCont_last::description( ) const
1116 {
1117         return strrefdup( "union" );
1118 }
1119
1120 void
1121 Kernel::UnionCont_last::gcMark( Kernel::GCMarkedSet & marked )
1122 {
1123         cont_->gcMark( marked );
1124 }
1125
1126
1127 Ast::UnionExpr::UnionExpr( const Ast::SourceLocation & loc, Ast::ArgListExprs * argList )
1128         : Ast::Expression( loc ), argList_( argList )
1129 { }
1130
1131 Ast::UnionExpr::~UnionExpr( )
1132 {
1133         delete argList_;
1134 }
1135
1136
1137 void
1138 Ast::UnionExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
1139 {
1140         argList_->analyze( this, env, freeStatesDst );
1141 }
1142
1143 void
1144 Ast::UnionExpr::eval( Kernel::EvalState * evalState ) const
1145 {
1146         evalState->cont_ = Kernel::ContRef( new Kernel::UnionCont_last( argList_, evalState->cont_, loc_ ) );
1147
1148         argList_->evaluate( RefCountPtr< Kernel::CallContInfo >( new Kernel::CallContInfo( argList_, *evalState, false ) ),
1149                                                                                         argList_->begin( ), Lang::THE_CONS_NULL,
1150                                                                                         evalState );
1151 }
1152
1153
1154 Kernel::SplitCont_1::SplitCont_1( const Ast::SourceLocation & traceLoc, Ast::Expression * argList, bool curry, const Kernel::EvalState & evalState, const Ast::SourceLocation & callLoc )
1155         : Kernel::Continuation( traceLoc ), argList_( argList ), curry_( curry ), env_( evalState.env_ ), dyn_( evalState.dyn_ ), cont_( evalState.cont_ ), callLoc_( callLoc )
1156 { }
1157
1158 Kernel::SplitCont_1::~SplitCont_1( )
1159 { }
1160
1161 void
1162 Kernel::SplitCont_1::takeValue( const RefCountPtr< const Lang::Value > & funUntyped, Kernel::EvalState * evalState, bool dummy ) const
1163 {
1164         typedef const Lang::Function ArgType;
1165         RefCountPtr< ArgType > fun = Helpers::down_cast< ArgType >( funUntyped, "Split's function" );
1166
1167         evalState->env_ = env_;
1168         evalState->dyn_ = dyn_;
1169         evalState->cont_ = Kernel::ContRef( new Kernel::SplitCont_2( fun, curry_, env_, dyn_, cont_, callLoc_ ) );
1170         evalState->expr_ = argList_;
1171 }
1172
1173 Kernel::ContRef
1174 Kernel::SplitCont_1::up( ) const
1175 {
1176         return cont_;
1177 }
1178
1179 RefCountPtr< const char >
1180 Kernel::SplitCont_1::description() const
1181 {
1182         return strrefdup( "split call's function" );
1183 }
1184
1185 void
1186 Kernel::SplitCont_1::gcMark( Kernel::GCMarkedSet & marked )
1187 {
1188         dyn_->gcMark( marked );
1189         cont_->gcMark( marked );
1190 }
1191
1192
1193 Kernel::SplitCont_2::SplitCont_2( const RefCountPtr< const Lang::Function > & fun, bool curry, const Kernel::PassedEnv & env, const Kernel::PassedDyn & dyn, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
1194         : Kernel::Continuation( callLoc ), fun_( fun ), curry_( curry ), env_( env ), dyn_( dyn ), cont_( cont )
1195 { }
1196
1197 Kernel::SplitCont_2::~SplitCont_2( )
1198 { }
1199
1200 void
1201 Kernel::SplitCont_2::takeValue( const RefCountPtr< const Lang::Value > & valsUntyped, Kernel::EvalState * evalState, bool dummy ) const
1202 {
1203         typedef const Lang::Structure ArgType;
1204         RefCountPtr< ArgType > structure = Helpers::down_cast< ArgType >( valsUntyped, "Split" );
1205
1206         Kernel::Arguments args = fun_->newCurriedArguments( );
1207         structure->argList_->bind( & args, structure->values_, env_, dyn_ );
1208
1209         if( curry_ )
1210                 {
1211                         evalState->cont_ = cont_;
1212                         cont_->takeValue( Kernel::ValueRef( new Lang::CuteFunction( fun_, args ) ),
1213                                                                                                 evalState );
1214                 }
1215         else
1216                 {
1217                         evalState->dyn_ = dyn_;
1218                         evalState->cont_ = cont_;
1219                         fun_->call( evalState, args, traceLoc_ );
1220                 }
1221 }
1222
1223 Kernel::ContRef
1224 Kernel::SplitCont_2::up( ) const
1225 {
1226         return cont_;
1227 }
1228
1229 RefCountPtr< const char >
1230 Kernel::SplitCont_2::description( ) const
1231 {
1232         return strrefdup( "Split/splice" );
1233 }
1234
1235 void
1236 Kernel::SplitCont_2::gcMark( Kernel::GCMarkedSet & marked )
1237 {
1238         cont_->gcMark( marked );
1239 }
1240
1241
1242 Ast::CallSplitExpr::CallSplitExpr( const Ast::SourceLocation & loc, Ast::Expression * funExpr, Ast::Expression * argList, bool curry )
1243         : Ast::Expression( loc ), curry_( curry ), funExpr_( funExpr ), argList_( argList )
1244 { }
1245
1246 Ast::CallSplitExpr::~CallSplitExpr( )
1247 {
1248         delete funExpr_;
1249         delete argList_;
1250 }
1251
1252
1253 void
1254 Ast::CallSplitExpr::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
1255 {
1256         funExpr_->analyze( this, env, freeStatesDst );
1257         argList_->analyze( this, env, freeStatesDst );
1258 }
1259
1260 void
1261 Ast::CallSplitExpr::eval( Kernel::EvalState * evalState ) const
1262 {
1263         evalState->expr_ = funExpr_;
1264         evalState->cont_ = Kernel::ContRef( new Kernel::SplitCont_1( evalState->expr_->loc( ), argList_, curry_, *evalState, loc_ ) );
1265 }
1266
1267
1268 Ast::DummyExpression::DummyExpression( )
1269         : Ast::Expression( Ast::THE_UNKNOWN_LOCATION )
1270 { }
1271
1272 Ast::DummyExpression::DummyExpression( const Ast::SourceLocation & loc )
1273         : Ast::Expression( loc )
1274 { }
1275
1276 Ast::DummyExpression::~DummyExpression( )
1277 { }
1278
1279 void
1280 Ast::DummyExpression::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
1281 {
1282         /* Nothing to do! */
1283 }
1284
1285 void
1286 Ast::DummyExpression::eval( Kernel::EvalState * evalState ) const
1287 {
1288         throw Exceptions::InternalError( strrefdup( "A DummyExpression must never be evaluated." ) );
1289 }
1290