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