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