source/classtypes.cc

   1 #include <cmath>
   2
   3 #include "shapestypes.h"
   4 #include "shapesexceptions.h"
   5 #include "astexpr.h"
   6 #include "globals.h"
   7 #include "consts.h"
   8 #include "angleselect.h"
   9 #include "astvar.h"
  10 #include "astclass.h"
  11 #include "autoonoff.h"
  12 #include "shapescore.h"
  13 #include "astfun.h"
  14
  15 #include <ctype.h>
  16 #include <stack>
  17 #include <string>
  18
  19 using namespace Shapes;
  20 using namespace std;
  21
  22
  23 Kernel::MethodId::MethodId( const RefCountPtr< const Lang::Class > & _myClass, const char * _msg )
  24         : myClass( _myClass ), msg( _msg )
  25 { }
  26
  27 Kernel::MethodId::~MethodId( )
  28 { }
  29
  30 const char *
  31 Kernel::MethodId::getIdentifier( ) const
  32 {
  33         return msg;
  34 }
  35
  36
  37 Lang::Instance::Instance( Kernel::PassedEnv _env, Kernel::PassedEnv _privateEnv, RefCountPtr< const Lang::Class > _myClass, bool _protectedAccess, const Kernel::PassedDyn & _my_dyn )
  38         : env( _env ), privateEnv( _privateEnv ), warm2D( 0 ), warm3D( 0 ), my_dyn( _my_dyn ), myClass( _myClass ), prepared( false ), protectedAccess( _protectedAccess )
  39 { }
  40
  41 DISPATCHIMPL( Instance );
  42
  43 Lang::Instance::~Instance( )
  44 { }
  45
  46 void
  47 Lang::Instance::gcMark( Kernel::GCMarkedSet & marked )
  48 {
  49         env->gcMark( marked );
  50         privateEnv->gcMark( marked );
  51         my_dyn->gcMark( marked );
  52 }
  53
  54
  55 void
  56 Lang::Instance::prepare( Kernel::EvalState * evalState )
  57 {
  58         if( prepared )
  59                 {
  60                         return;
  61                 }
  62         prepared = true;
  63         {
  64                 for( std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > >::iterator i = parents->begin( ); i != parents->end( ); ++i )
  65                         {
  66                                 i->second->prepare( evalState );
  67                         }
  68         }
  69
  70         myClass->prepareInstance( evalState, privateEnv );
  71 }
  72
  73 Kernel::VariableHandle
  74 Lang::Instance::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & dummySelfRef ) const
  75 {
  76         if( ! myClass->getFinal( ) )
  77                 {
  78                         throw Exceptions::IllegalFinalReference( myClass->getPrettyName( ), fieldID );
  79                 }
  80
  81         return getLocalField( fieldID );
  82 }
  83
  84 Kernel::VariableHandle
  85 Lang::Instance::getLocalField( const char * fieldID ) const
  86 {
  87         if( protectedAccess )
  88                 {
  89                         if( myClass->isInProtectedGetSet( fieldID ) )
  90                                 {
  91                                         throw Exceptions::NotImplemented( "Instance::getLocalField" );
  92                                         //                                      Kernel::Environment::LexicalKey key = env->findLexicalVariableKey( Ast::THE_UNKNOWN_LOCATION, fieldID );
  93                                         //                                      return env->getVarHandle( key );
  94                                 }
  95                         throw Exceptions::NonExistentMember( myClass->getPrettyName( ), fieldID );
  96                 }
  97         else
  98                 {
  99                         if( myClass->isInPublicGetSet( fieldID ) )
 100                                 {
 101                                         throw Exceptions::NotImplemented( "Instance::getLocalField" );
 102                                         //                                      Kernel::Environment::LexicalKey key = env->findLexicalVariableKey( Ast::THE_UNKNOWN_LOCATION, fieldID );
 103                                         //                                      return env->getVarHandle( key );
 104                                 }
 105                         if( myClass->isInProtectedGetSet( fieldID ) )
 106                                 {
 107                                         throw Exceptions::ProtectedMemberPublicScope( myClass->getPrettyName( ), fieldID );
 108                                 }
 109                         throw Exceptions::NonExistentMember( myClass->getPrettyName( ), fieldID );
 110                 }
 111 }
 112
 113 void
 114 Lang::Instance::tackOn( const char * fieldID, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
 115 {
 116         if( ! myClass->getFinal( ) )
 117                 {
 118                         throw Exceptions::IllegalFinalReference( myClass->getPrettyName( ), fieldID );
 119                 }
 120
 121         tackOnLocal( fieldID, evalState, piece, callLoc );
 122 }
 123
 124 void
 125 Lang::Instance::tackOnLocal( const char * fieldID, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
 126 {
 127         if( protectedAccess )
 128                 {
 129                         if( myClass->isInProtectedSetSet( fieldID ) )
 130                                 {
 131                                         throw Exceptions::NotImplemented( "Instance::tackOnLocal" );
 132                                         //                                      Kernel::Environment::LexicalKey key = env->findLexicalVariableKey( Ast::THE_UNKNOWN_LOCATION, fieldID );
 133                                         //                                      env->tackOn( key, evalState, piece, callLoc );
 134                                         return;
 135                                 }
 136                         if( myClass->isInProtectedGetSet( fieldID ) )
 137                                 {
 138                                         throw Exceptions::MemberNotAssignable( myClass->getPrettyName( ), fieldID, Interaction::PROTECTED_SCOPE_NAME );
 139                                 }
 140                         throw Exceptions::NonExistentMember( myClass->getPrettyName( ), fieldID );
 141                 }
 142         else
 143                 {
 144                         if( myClass->isInPublicSetSet( fieldID ) )
 145                                 {
 146                                         throw Exceptions::NotImplemented( "Instance::tackOnLocal" );
 147                                         //                                      Kernel::Environment::LexicalKey key = env->findLexicalVariableKey( Ast::THE_UNKNOWN_LOCATION, fieldID );
 148                                         //                                      env->tackOn( key, evalState, piece, callLoc );
 149                                         return;
 150                                 }
 151                         if( myClass->isInPublicGetSet( fieldID ) )
 152                                 {
 153                                         throw Exceptions::MemberNotAssignable( myClass->getPrettyName( ), fieldID, Interaction::PUBLIC_SCOPE_NAME );
 154                                 }
 155                         if( myClass->isInProtectedGetSet( fieldID ) )
 156                                 {
 157                                         throw Exceptions::ProtectedMemberPublicScope( myClass->getPrettyName( ), fieldID );
 158                                 }
 159                         throw Exceptions::NonExistentMember( myClass->getPrettyName( ), fieldID );
 160                 }
 161 }
 162
 163 RefCountPtr< const Lang::Function >
 164 Lang::Instance::getMethod( Kernel::MethodId fieldID ) const
 165 {
 166         typedef typeof methodTable MethodMapType;
 167         MethodMapType::iterator i = methodTable.find( fieldID );
 168         if( i != methodTable.end( ) )
 169                 {
 170                         return i->second;
 171                 }
 172
 173         const RefCountPtr< const Lang::Class > & defClass = myClass->getMethodDefinitionClass( fieldID );
 174
 175         RefCountPtr< const Lang::Function > fun = NullPtr< const Lang::Function >( );
 176
 177         if( defClass == myClass )
 178                 {
 179                         fun = getLocalMethod( fieldID );
 180                 }
 181         else
 182                 {
 183                         typedef typeof *parents ParentMapType;
 184                         ParentMapType::const_iterator p = parents->find( defClass );
 185                         if( p == parents->end( ) )
 186                                 {
 187                                         throw Exceptions::InternalError( "The class defining a method was not found among the parents." );
 188                                 }
 189                         fun = p->second->getLocalMethod( fieldID );
 190                 }
 191
 192         methodTable.insert( i, MethodMapType::value_type( fieldID, fun ) );
 193
 194         return fun;
 195 }
 196
 197 RefCountPtr< const Lang::Function >
 198 Lang::Instance::getLocalMethod( Kernel::MethodId fieldID ) const
 199 {
 200
 201         if( fieldID.getClass( ) == myClass )
 202                 {
 203                         Kernel::VariableHandle untypedFun = getLocalField( fieldID.getIdentifier( ) );
 204                         return untypedFun->getVal< const Lang::Function >( "getLocalMethod:     The user was (almost) able to retrieve member data from super instance." );
 205                 }
 206
 207         typedef typeof overrides ClassMapType;
 208         ClassMapType::const_iterator i = overrides.find( fieldID.getClass( ) );
 209         if( i == overrides.end( ) )
 210                 {
 211                         throw Exceptions::NoSuchLocalMethod( myClass, fieldID );
 212                 }
 213
 214         typedef typeof i->second IdMapType;
 215
 216         IdMapType::const_iterator j = i->second.find( fieldID.getIdentifier( ) );
 217         if( j == i->second.end( ) )
 218                 {
 219                         throw Exceptions::NoSuchLocalMethod( myClass, fieldID );
 220                 }
 221         return j->second;
 222 }
 223
 224 RefCountPtr< const Lang::Instance >
 225 Lang::Instance::superReference( RefCountPtr< const Lang::Class > parent ) const
 226 {
 227         typedef typeof *parents ParentMapType;
 228         ParentMapType::const_iterator p = parents->find( parent );
 229         if( p == parents->end( ) )
 230                 {
 231                         throw Exceptions::SuperReferenceClassNotParent( myClass, parent );
 232                 }
 233         return p->second;
 234 }
 235
 236 RefCountPtr< const Lang::Geometric2D >
 237 Lang::Instance::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
 238 {
 239         return RefCountPtr< const Lang::Geometric2D >( new Lang::TransformedInstance( tf, self.down_cast< const Lang::Instance >( ) ) );
 240 }
 241
 242 void
 243 Lang::Instance::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
 244 {
 245         if( ! myClass->method_isa( Lang::Drawable2D::TypeID ) )
 246                 {
 247                         throw Exceptions::InternalError( "Invoking Instance::shipout on a non Drawable object should not be possible" );
 248                 }
 249
 250         if( warm2D == 0 )
 251                 {
 252                         throw Exceptions::InternalError( "Instance::shipout: warm2D == 0." );
 253                 }
 254
 255         /*
 256         RefCountPtr< const Lang::Value > val = getMethod( Kernel::MethodId( Lang::Drawable2D::TypeID, Shapes::MESSAGE_DRAWABLE_DRAW_ID ) )->call( dstgroup, my_pdfo, & stateCopy, Kernel::EMPTY_ARGLIST );
 257         if( dynamic_cast< const Lang::Void * >( val.getPtr( ) ) == 0 )
 258                 {
 259                         throw Exceptions::TypeMismatch( val->getTypeName( ), Lang::Void::staticTypeName( ) );
 260                 }
 261         */
 262
 263         warm2D->getPile( )->shipout( os, pdfState, tf );
 264 }
 265
 266 RefCountPtr< const Lang::ElementaryPath2D >
 267 Lang::Instance::bbox( ) const
 268 {
 269         if( ! myClass->method_isa( Lang::Drawable2D::TypeID ) )
 270                 {
 271                         throw Exceptions::InternalError( "Invoking Instance::shipout on a non Drawable object should not be possible" );
 272                 }
 273
 274         if( warm2D == 0 )
 275                 {
 276                         throw Exceptions::InternalError( "Instance::shipout: warm2D == 0." );
 277                 }
 278
 279         return warm2D->getPile( )->bbox( );
 280 }
 281
 282 RefCountPtr< const char >
 283 Lang::Instance::staticTypeName( )
 284 {
 285         return strrefdup( "<Instance>" );
 286 }
 287
 288 const RefCountPtr< const Lang::Class > &
 289 Lang::Instance::getClass( ) const
 290 {
 291         return myClass;
 292 }
 293
 294 void
 295 Lang::Instance::show( std::ostream & os ) const
 296 {
 297         os << "Instance of class " << myClass->getPrettyName( ).getPtr( ) ;
 298 }
 299
 300
 301 Lang::TransformedInstance::TransformedInstance( const Lang::Transform2D & _tf, const RefCountPtr< const Lang::Instance > & _obj )
 302         : tf( _tf ), obj( _obj )
 303 { }
 304
 305 Lang::TransformedInstance::~TransformedInstance( )
 306 { }
 307
 308 Kernel::VariableHandle
 309 Lang::TransformedInstance::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & dummySelfRef ) const
 310 {
 311         if( obj->getClass( )->isInTransformingSet( fieldID ) )
 312                 {
 313                         Kernel::VariableHandle argUntyped = obj->getField( fieldID, obj );
 314                         typedef const Lang::Geometric2D ArgType;
 315                         RefCountPtr< ArgType > arg = argUntyped->getVal< ArgType >( "<inside transformed instance getField>" );
 316                         return Kernel::VariableHandle( new Kernel::Variable( arg->transformed( tf, arg ) ) );
 317                 }
 318         return obj->getField( fieldID, obj );
 319 }
 320
 321 RefCountPtr< const Lang::Function >
 322 Lang::TransformedInstance::getMethod( Kernel::MethodId fieldID ) const
 323 {
 324         /* Fetch the method first to make sure it exists, then see whether it is transforming.
 325          */
 326         RefCountPtr< const Lang::Function > arg = obj->getMethod( fieldID );
 327         if( arg->isTransforming( ) )
 328                 {
 329                         return RefCountPtr< const Lang::Function >( new Lang::TransformedFunction2D( tf, arg ) );
 330                 }
 331         return arg;
 332 }
 333
 334 RefCountPtr< const Lang::Geometric2D >
 335 Lang::TransformedInstance::transformed( const Lang::Transform2D & tf2, const RefCountPtr< const Lang::Geometric2D > & self ) const
 336 {
 337         return RefCountPtr< const Lang::Geometric2D >( new Lang::TransformedInstance( Lang::Transform2D( tf2, tf ) , obj ) );
 338 }
 339
 340
 341 void
 342 Lang::TransformedInstance::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tfIn ) const
 343 {
 344         obj->shipout( os, pdfState, Lang::Transform2D( tfIn, tf ) );
 345 }
 346
 347 RefCountPtr< const Lang::ElementaryPath2D >
 348 Lang::TransformedInstance::bbox( ) const
 349 {
 350         return obj->bbox( )->elementaryTransformed( tf );
 351 }
 352
 353 RefCountPtr< const Lang::Class > Lang::TransformedInstance::TypeID( new Lang::SystemFinalClass( strrefdup( "TransformedInstance" ) ) );
 354 TYPEINFOIMPL( TransformedInstance );
 355
 356 void
 357 Lang::TransformedInstance::show( std::ostream & os ) const
 358 {
 359         os << "Transformed instance.    The class is not available in this implementation." ;
 360 }
 361
 362 void
 363 Lang::TransformedInstance::gcMark( Kernel::GCMarkedSet & marked )
 364 {
 365         const_cast< Lang::Instance * >( obj.getPtr( ) )->gcMark( marked );
 366 }
 367
 368 RefCountPtr< const char >
 369 Kernel::MethodId::prettyName( ) const
 370 {
 371         string res = myClass->getPrettyName( ).getPtr( );
 372         res += "#";
 373         res += msg;
 374         return strrefdup( res.c_str( ) );
 375 }
 376
 377 bool
 378 Kernel::operator < ( const Kernel::MethodId & mid1, const Kernel::MethodId & mid2 )
 379 {
 380         if( mid1.myClass < mid2.myClass )
 381                 {
 382                         return true;
 383                 }
 384         if( mid1.myClass > mid2.myClass )
 385                 {
 386                         return false;
 387                 }
 388         return strcmp( mid1.msg, mid2.msg ) < 0;
 389 }
 390
 391
 392 Lang::Class::Class( RefCountPtr< const char > _prettyName )
 393         : prettyName( _prettyName ), selfRef( NullPtr< Lang::Class >( ) ), isFinal( false )
 394 { }
 395
 396 Lang::Class::~Class( )
 397 {
 398         /* Knowing that each class is reference counted, the destructor is being called as an effect
 399          * of the reference count reaching zero.        Thus, the self reference must simply be detached
 400          * from this object, to avoid cyclic destruction.
 401          */
 402         selfRef.abortPtr( );
 403 }
 404
 405 void
 406 Lang::Class::setSelfRef( RefCountPtr< const Lang::Class > _selfRef ) const
 407 {
 408         selfRef = _selfRef; // selfRef is mutable!
 409         /* Don't count this cyclic reference!
 410          */
 411         --*selfRef.getCounterPtr( );
 412 }
 413
 414 RefCountPtr< const Lang::Class > Lang::Class::TypeID( new Lang::MetaClass( ) );
 415 TYPEINFOIMPL( Class );
 416
 417 RefCountPtr< const char >
 418 Lang::Class::getPrettyName( ) const
 419 {
 420         return prettyName;
 421 }
 422
 423 bool
 424 Lang::Class::isInPublicGetSet( const char * field ) const
 425 {
 426         return false;
 427 }
 428
 429 bool
 430 Lang::Class::isInPublicSetSet( const char * field ) const
 431 {
 432         return false;
 433 }
 434
 435 bool
 436 Lang::Class::isInProtectedGetSet( const char * field ) const
 437 {
 438         return false;
 439 }
 440
 441 bool
 442 Lang::Class::isInProtectedSetSet( const char * field ) const
 443 {
 444         return false;
 445 }
 446
 447 bool
 448 Lang::Class::isInTransformingSet( const char * field ) const
 449 {
 450         return false;
 451 }
 452
 453 RefCountPtr< const Lang::Function >
 454 Lang::Class::getMutator( const char * mutatorID ) const
 455 {
 456         throw Exceptions::InternalError( "Mutator request not defined for this type of class." );
 457 }
 458
 459 void
 460 Lang::Class::showAbstractSet( std::ostream & os ) const
 461 {
 462         os << "{" ;
 463         typedef typeof abstractSet SetType;
 464         for( SetType::const_iterator i = abstractSet.begin( ); i != abstractSet.end( ); ++i )
 465                 {
 466                         os << " " << i->prettyName( ) ;
 467                 }
 468         os << " }" ;
 469 }
 470
 471
 472 void
 473 Lang::Class::show( std::ostream & os ) const
 474 {
 475         os << "Pretty-name: " << prettyName.getPtr( ) ;
 476
 477         if( ! abstractSet.empty( ) )
 478                 {
 479                         os << ", +" ;
 480                 }
 481         else
 482                 {
 483                         os << ", -" ;
 484                 }
 485         os << "abstract" ;
 486
 487         if( isFinal )
 488                 {
 489                         os << ", +" ;
 490                 }
 491         else
 492                 {
 493                         os << ", -" ;
 494                 }
 495         os << "final" ;
 496
 497         {
 498                 bool isRepeatable = false;
 499                 try
 500                         {
 501                                 isRepeatable = this->isRepeatableBase( );
 502                         }
 503                 catch( const Exceptions::MiscellaneousRequirement & ball )
 504                         {
 505                                 /* Probably something saying that MetaClass is not repeatable... */
 506                         }
 507
 508                 if( isRepeatable )
 509                         {
 510                                 os << ", +" ;
 511                         }
 512                 else
 513                         {
 514                                 os << ", -" ;
 515                         }
 516                 os << "repeatable" ;
 517         }
 518 }
 519
 520 Kernel::VariableHandle
 521 Lang::Class::getField( const char * fieldId, const RefCountPtr< const Lang::Value > & dummySelfRef ) const
 522 {
 523         if( strcmp( fieldId, "new" ) == 0 )
 524                 {
 525                         return Helpers::newValHandle( new Lang::ClassMethodNew( selfRef ) );
 526                 }
 527         if( strcmp( fieldId, "isa" ) == 0 )
 528                 {
 529                         return Helpers::newValHandle( new Lang::ClassMethodIsa( selfRef ) );
 530                 }
 531         if( strcmp( fieldId, "name" ) == 0 )
 532                 {
 533                         return Helpers::newValHandle( new Lang::String( prettyName ) );
 534                 }
 535         throw Exceptions::NonExistentMember( getTypeName( ), fieldId );
 536 }
 537
 538 bool
 539 Lang::Class::getFinal( ) const
 540 {
 541         return isFinal;
 542 }
 543
 544 const Lang::Class::MessageMapType &
 545 Lang::Class::getMessageMap( ) const
 546 {
 547         return messageMap;
 548 }
 549
 550 const RefCountPtr< const Lang::Class > &
 551 Lang::Class::getMethodDefinitionClass( const Kernel::MethodId & method ) const
 552 {
 553         MessageMapType::const_iterator i = messageMap.find( method );
 554         if( i == messageMap.end( ) )
 555                 {
 556                         throw Exceptions::NoSuchMethod( selfRef, method );
 557                 }
 558         if( i->second.empty( ) )
 559                 {
 560                         throw Exceptions::InternalError( "Asking for class defining abstract method." );
 561                 }
 562         return *( i->second.begin( ) );
 563 }
 564
 565
 566 void
 567 Lang::Class::findParents( std::set< RefCountPtr< const Lang::Class > > * _allParents, std::set< RefCountPtr< const Lang::Class > > * _multiParents ) const
 568 {
 569         typedef typeof *_allParents SetType;
 570         SetType::const_iterator i = _allParents->find( selfRef );
 571         if( i != _allParents->end( ) )
 572                 {
 573                         _multiParents->insert( selfRef );
 574                 }
 575         else
 576                 {
 577                         _allParents->insert( i, selfRef );
 578                 }
 579 }
 580
 581 void
 582 Lang::Class::prepareInstance( Kernel::EvalState * evalState, Kernel::PassedEnv privateEnv ) const
 583 {
 584         /* Only UserClass instances do any preparations. */
 585 }
 586
 587 DISPATCHIMPL( Class );
 588
 589
 590
 591 Lang::Object::Object( )
 592         : Lang::Class( strrefdup( "Object" ) ), dummyEnv( NullPtr< Kernel::Environment >( ) )
 593 { }
 594
 595 Lang::Object::~Object( )
 596 { }
 597
 598 Kernel::ValueRef
 599 Lang::Object::method_new( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 600 {
 601         const size_t ARITY = 0;
 602         CHECK_ARITY( args, ARITY, Kernel::MethodId( Lang::Class::TypeID, "new" ).prettyName( ) );
 603
 604         return RefCountPtr< const Lang::Geometric2D >( new Lang::Instance( dummyEnv, dummyEnv, selfRef, false, evalState->dyn_ ) );
 605 }
 606
 607 bool
 608 Lang::Object::method_isa( RefCountPtr< const Lang::Class > T ) const
 609 {
 610         return T == selfRef;
 611 }
 612
 613 void
 614 Lang::Object::findMultiplyInheritedClasses( std::set< RefCountPtr< Lang::Class > > * visited, std::set< RefCountPtr< Lang::Class > > * found ) const
 615 {
 616         /* There are no parent classes to consider. */
 617 }
 618
 619 void
 620 Lang::Object::assertMethodOverridable( const char * id, const RefCountPtr< const Lang::Class > & caller ) const
 621 {
 622         throw Exceptions::OverridingUndeclaredMethod( caller, selfRef, id );
 623 }
 624
 625 void
 626 Lang::Object::superNew( RefCountPtr< Lang::Instance > instanceSelf,
 627                                                                                                          RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects,
 628                                                                                                          Kernel::Arguments & emptyArglist,
 629                                                                                                          Kernel::EvalState * evalState ) const
 630 {
 631         std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > >::iterator i = createdObjects->find( selfRef );
 632         if( i != createdObjects->end( ) )
 633                 {
 634                         return;
 635                 }
 636         Lang::Instance * newObj = new Lang::Instance( dummyEnv, dummyEnv, selfRef, true, evalState->dyn_ );
 637         newObj->parents = createdObjects;
 638         createdObjects->insert( i, pair< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > >( selfRef, RefCountPtr< Lang::Instance >( newObj ) ) );
 639 }
 640
 641 bool
 642 Lang::Object::isRepeatableBase( ) const
 643 {
 644         return true;
 645 }
 646
 647 void
 648 Lang::Object::gcMark( Kernel::GCMarkedSet & marked )
 649 { }
 650
 651 Lang::MetaClass::MetaClass( )
 652         : Lang::Class( strrefdup( "MetaClass" ) )
 653 { }
 654
 655 Lang::MetaClass::~MetaClass( )
 656 { }
 657
 658 Kernel::ValueRef
 659 Lang::MetaClass::method_new( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 660 {
 661         throw Exceptions::MiscellaneousRequirement( "Calling the \"new\" method of MetaClass is actually not the way to create new classes, sorry." );
 662 }
 663
 664 bool
 665 Lang::MetaClass::method_isa( RefCountPtr< const Lang::Class > T ) const
 666 {
 667         return T == Lang::Class::TypeID || T == Lang::THE_OBJECT;
 668 }
 669
 670 void
 671 Lang::MetaClass::findMultiplyInheritedClasses( std::set< RefCountPtr< Lang::Class > > * visited, std::set< RefCountPtr< Lang::Class > > * found ) const
 672 {
 673         /* There are no parent classes to consider. */
 674 }
 675
 676 void
 677 Lang::MetaClass::assertMethodOverridable( const char * id, const RefCountPtr< const Lang::Class > & caller ) const
 678 {
 679         if( strcmp( id, "new" ) == 0 ||
 680                         strcmp( id, "isa" ) == 0 )
 681                 {
 682                         throw Exceptions::OverridingFinalMethod( caller, selfRef, id );
 683                 }
 684         throw Exceptions::OverridingUndeclaredMethod( caller, selfRef, id );
 685 }
 686
 687 void
 688 Lang::MetaClass::superNew( RefCountPtr< Lang::Instance > instanceSelf,
 689                                                                                                                         RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects,
 690                                                                                                                         Kernel::Arguments & emptyArglist,
 691                                                                                                                         Kernel::EvalState * evalState ) const
 692 {
 693         throw Exceptions::MiscellaneousRequirement( "It is forbidden to inherit from MetaClass, sorry." );
 694 }
 695
 696 void
 697 Lang::MetaClass::findParents( std::set< RefCountPtr< const Lang::Class > > * _allParents, std::set< RefCountPtr< const Lang::Class > > * _multiParents ) const
 698 {
 699         throw Exceptions::MiscellaneousRequirement( "It is forbidden to inherit from MetaClass, sorry." );
 700 }
 701
 702 bool
 703 Lang::MetaClass::isRepeatableBase( ) const
 704 {
 705         throw Exceptions::MiscellaneousRequirement( "MetaClass can certainly not be a repeated base." );
 706 }
 707
 708 void
 709 Lang::MetaClass::gcMark( Kernel::GCMarkedSet & marked )
 710 { }
 711
 712
 713
 714 Lang::SystemFinalClass::SystemFinalClass( RefCountPtr< const char > _prettyName )
 715         : Lang::Class( _prettyName ), registerMutatorFunction_( 0 )
 716 { }
 717
 718 Lang::SystemFinalClass::SystemFinalClass( RefCountPtr< const char > _prettyName, RegisterMutatorFunction registerMutatorFunction )
 719         : Lang::Class( _prettyName ), registerMutatorFunction_( registerMutatorFunction )
 720 { }
 721
 722 Lang::SystemFinalClass::~SystemFinalClass( )
 723 { }
 724
 725 void
 726 Lang::SystemFinalClass::initMutators( )
 727 {
 728         if( registerMutatorFunction_ != 0 )
 729                 {
 730                         registerMutatorFunction_( this );
 731                 }
 732 }
 733
 734 void
 735 Lang::SystemFinalClass::registerMutator( Lang::CoreFunction * fun )
 736 {
 737         typedef typeof mutators_ MapType;
 738         mutators_.insert( MapType::value_type( fun->getTitle( ), RefCountPtr< const Lang::Function >( fun ) ) );
 739 }
 740
 741 Kernel::ValueRef
 742 Lang::SystemFinalClass::method_new( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 743 {
 744         throw Exceptions::MiscellaneousRequirement( "Use dedicated syntax rather than calling the \"new\" method of a system class." );
 745 }
 746
 747 bool
 748 Lang::SystemFinalClass::method_isa( RefCountPtr< const Lang::Class > T ) const
 749 {
 750         return T == selfRef || T == Lang::THE_OBJECT;
 751 }
 752
 753 void
 754 Lang::SystemFinalClass::findMultiplyInheritedClasses( std::set< RefCountPtr< Lang::Class > > * visited, std::set< RefCountPtr< Lang::Class > > * found ) const
 755 {
 756         /* There are no parent classes to consider. */
 757 }
 758
 759 void
 760 Lang::SystemFinalClass::assertMethodOverridable( const char * id, const RefCountPtr< const Lang::Class > & caller ) const
 761 {
 762         throw Exceptions::OverridingUndeclaredMethod( caller, selfRef, id );
 763 }
 764
 765 void
 766 Lang::SystemFinalClass::superNew( RefCountPtr< Lang::Instance > instanceSelf,
 767                                                                                                                                                  RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects,
 768                                                                                                                                                  Kernel::Arguments & emptyArglist,
 769                                                                                                                                                  Kernel::EvalState * evalState ) const
 770 {
 771         throw Exceptions::MiscellaneousRequirement( "It is forbidden to inherit from SystemFinalClass, sorry." );
 772 }
 773
 774 bool
 775 Lang::SystemFinalClass::isRepeatableBase( ) const
 776 {
 777         return false;
 778 }
 779
 780 RefCountPtr< const Lang::Function >
 781 Lang::SystemFinalClass::getMutator( const char * mutatorID ) const
 782 {
 783         typedef typeof mutators_ MapType;
 784         MapType::const_iterator i = mutators_.find( mutatorID );
 785         if( i == mutators_.end( ) )
 786                 {
 787                         throw Exceptions::NonExistentMutator( staticTypeName( ), mutatorID );
 788                 }
 789         return i->second;
 790 }
 791
 792 void
 793 Lang::SystemFinalClass::gcMark( Kernel::GCMarkedSet & marked )
 794 { }
 795
 796
 797 Lang::SystemVirtualInterface::SystemVirtualInterface( RefCountPtr< const char > _prettyName )
 798         : Lang::Class( _prettyName )
 799 { }
 800
 801 Lang::SystemVirtualInterface::~SystemVirtualInterface( )
 802 { }
 803
 804 void
 805 Lang::SystemVirtualInterface::addVirtual( const char * id )
 806 {
 807         messageMap[ Kernel::MethodId( selfRef, id ) ];
 808 }
 809
 810 Kernel::ValueRef
 811 Lang::SystemVirtualInterface::method_new( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 812 {
 813         throw Exceptions::InstantiatingAbstractClass( selfRef );
 814 }
 815
 816 bool
 817 Lang::SystemVirtualInterface::method_isa( RefCountPtr< const Lang::Class > T ) const
 818 {
 819         throw Exceptions::InternalError( "method_isa was called on an abstract system class." );
 820 }
 821
 822 void
 823 Lang::SystemVirtualInterface::findMultiplyInheritedClasses( std::set< RefCountPtr< Lang::Class > > * visited, std::set< RefCountPtr< Lang::Class > > * found ) const
 824 {
 825         /* There are no parent classes to consider. */
 826 }
 827
 828 void
 829 Lang::SystemVirtualInterface::assertMethodOverridable( const char * id, const RefCountPtr< const Lang::Class > & caller ) const
 830 {
 831         if( messageMap.find( Kernel::MethodId( selfRef, id ) ) == messageMap.end( ) )
 832                 {
 833                         throw Exceptions::OverridingUndeclaredMethod( caller, selfRef, id );
 834                 }
 835 }
 836
 837 void
 838 Lang::SystemVirtualInterface::superNew( RefCountPtr< Lang::Instance > instanceSelf,
 839                                                                                                                                                                          RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects,
 840                                                                                                                                                                          Kernel::Arguments & emptyArglist,
 841                                                                                                                                                                          Kernel::EvalState * evalState ) const
 842 { }
 843
 844 bool
 845 Lang::SystemVirtualInterface::isRepeatableBase( ) const
 846 {
 847         return true;
 848 }
 849
 850 void
 851 Lang::SystemVirtualInterface::gcMark( Kernel::GCMarkedSet & marked )
 852 { }
 853
 854
 855 Lang::UserClass::UserClass( const Ast::ClassFunction * _classExpr,
 856                                                                                                                          Kernel::PassedEnv _env,
 857                                                                                                                          RefCountPtr< const char > _prettyName,
 858                                                                                                                          Kernel::EvaluatedFormals * _formals,
 859                                                                                                                          RefCountPtr< std::list< std::pair< RefCountPtr< const Lang::Class >, const Ast::ArgListExprs * > > > _parents,
 860                                                                                                                          RefCountPtr< std::map< RefCountPtr< const Lang::Class >, std::list< Ast::MemberDeclaration * > > > _overrides,
 861                                                                                                                          bool _isFinal )
 862         : Lang::Class( _prettyName ), classExpr( _classExpr ), formals( _formals ), env( _env ), parents( _parents ), overrides( _overrides )
 863 {
 864         Lang::Class::isFinal = _isFinal;
 865 }
 866
 867 Lang::UserClass::~UserClass( )
 868 {
 869         delete formals;
 870 }
 871
 872 void
 873 Lang::UserClass::setupAndCheck( bool declaredAbstract )
 874 {
 875         for( std::list< std::pair< RefCountPtr< const Lang::Class >, const Ast::ArgListExprs * > >::const_iterator i = parents->begin( ); i != parents->end( ); ++i )
 876                 {
 877                         typedef typeof immediateParents SetType;
 878                         SetType::const_iterator j = immediateParents.find( i->first );
 879                         if( j != immediateParents.end( ) )
 880                                 {
 881                                         throw Exceptions::RepeatedImmediateParent( selfRef, i->first );
 882                                 }
 883                         if( i->first->getFinal( ) )
 884                                 {
 885                                         throw Exceptions::InheritingFinal( selfRef, i->first );
 886                                 }
 887                         immediateParents.insert( j, i->first );
 888                 }
 889
 890         findParents( & allParents, & multiParents );
 891
 892         for( std::set< RefCountPtr< const Lang::Class > >::const_iterator i = multiParents.begin( ); i != multiParents.end( ); ++i )
 893                 {
 894                         if( ! (*i)->isRepeatableBase( ) )
 895                                 {
 896                                         throw Exceptions::IllegalRepeatedBase( selfRef, *i );
 897                                 }
 898                 }
 899
 900         messageMap = classExpr->getLocalMessageMap( selfRef );
 901
 902         for( std::set< RefCountPtr< const Lang::Class > >::const_iterator i = immediateParents.begin( ); i != immediateParents.end( ); ++i )
 903                 {
 904                         const MessageMapType & parentMap = (*i)->getMessageMap( );
 905                         for( MessageMapType::const_iterator j = parentMap.begin( ); j != parentMap.end( ); ++j )
 906                                 {
 907                                         std::set< RefCountPtr< const Lang::Class > > & messageSet = messageMap[ j->first ];
 908                                         std::set< RefCountPtr< const Lang::Class > > res;
 909                                         set_union( messageSet.begin( ), messageSet.end( ),
 910                                                                                  j->second.begin( ), j->second.end( ),
 911                                                                                  insert_iterator< std::set< RefCountPtr< const Lang::Class > > >( res, res.begin( ) ) );
 912                                         messageSet = res;
 913                                 }
 914                 }
 915
 916         {
 917                 typedef typeof *overrides MapType;
 918                 for( MapType::const_iterator i = overrides->begin( ); i != overrides->end( ); ++i )
 919                         {
 920                                 typedef typeof allParents ClassSetType;
 921                                 {
 922                                         ClassSetType::const_iterator j = allParents.find( i->first );
 923                                         if( j == allParents.end( ) )
 924                                                 {
 925                                                         throw Exceptions::OverridingNonParent( selfRef, i->first );
 926                                                 }
 927                                 }
 928                                 {
 929                                         typedef typeof i->second ListType;
 930                                         for( ListType::const_iterator j = i->second.begin( ); j != i->second.end( ); ++j )
 931                                                 {
 932                                                         i->first->assertMethodOverridable( (*j)->id_, selfRef );
 933                                                         std::set< RefCountPtr< const Lang::Class > > & messageSet = messageMap[ Kernel::MethodId( i->first, (*j)->id_ ) ];
 934                                                         messageSet.clear( );
 935                                                         messageSet.insert( messageSet.begin( ), selfRef );
 936                                                 }
 937                                 }
 938                         }
 939         }
 940
 941
 942         {
 943                 /*
 944                 std::cerr << "Message map of " << getPrettyName( ) << ":" << std::endl ;
 945                 */
 946                 std::set< Kernel::MethodId >::iterator j = abstractSet.begin( );
 947                 MessageMapType::iterator k = messageMap.begin( );
 948                 for( MessageMapType::const_iterator i = messageMap.begin( ); i != messageMap.end( ); ++i )
 949                         {
 950                                 /*
 951                                 std::cerr << "  " << i->first.prettyName( ) << " --> " ;
 952                                 for( std::set< RefCountPtr< const Lang::Class > >::const_iterator l = i->second.begin( ); l != i->second.end( ); ++l )
 953                                         {
 954                                                 std::cerr << (*l)->getPrettyName( ) << " " ;
 955                                         }
 956                                 std::cerr << std::endl ;
 957                                 */
 958                                 if( i->second.size( ) == 1 )
 959                                         {
 960                                                 continue;
 961                                         }
 962                                 if( i->second.empty( ) )
 963                                         {
 964                                                 j = abstractSet.insert( j, i->first );
 965                                         }
 966                                 else
 967                                         {
 968                                                 throw Exceptions::AmbiguousInheritedMethod( selfRef, i->first.prettyName( ), i->second );
 969                                         }
 970                         }
 971         }
 972
 973         if( ! declaredAbstract && ! abstractSet.empty( ) )
 974                 {
 975                         throw Exceptions::FailedToDeclareClassAbstract( selfRef, classExpr );
 976                 }
 977 }
 978
 979 Kernel::ValueRef
 980 Lang::UserClass::method_new( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
 981 {
 982         if( ! abstractSet.empty( ) )
 983                 {
 984                         throw Exceptions::InstantiatingAbstractClass( selfRef );
 985                 }
 986
 987         throw Exceptions::NotImplemented( "UserClass::method_new" );
 988
 989 //       //     std::vector< VariableHandle > * envValues = new std::vector< VariableHandle >;
 990 //       //     envValues->reserve( argumentOrder->size( ) );
 991 //       //     while( envValues->size( ) < argumentOrder->size( ) )
 992 //       //             {
 993 //       //                     envValues->push_back( NullPtr< Kernel::Variable >( ) );
 994 //       //             }
 995 //       Kernel::PassedEnv instanceEnv( new Kernel::Environment( Shapes::theEnvironmentList, evalState->env_, argumentOrder, RefCountPtr< std::vector< VariableHandle > >( envValues ) ) );
 996
 997 //       //     std::vector< VariableHandle > * envValues = new std::vector< VariableHandle >;
 998 //       //     envValues->reserve( argumentOrder->size( ) );
 999 //       //     while( envValues->size( ) < argumentOrder->size( ) )
1000 //       //             {
1001 //       //                     envValues->push_back( NullPtr< Kernel::Variable >( ) );
1002 //       //             }
1003 //       Kernel::PassedEnv privateEnv( new Kernel::Environment( Shapes::theEnvironmentList, instanceEnv, argumentOrder, RefCountPtr< std::vector< VariableHandle > >( envValues ) ) );
1004
1005 //       RefCountPtr< Lang::Instance > instanceSelf = RefCountPtr< Lang::Instance >( new Lang::Instance( instanceEnv, privateEnv, selfRef, false, evalState->dyn_ ) );
1006
1007 //       privateEnv->define( classExpr->loc( ), SELF_ID, RefCountPtr< const Lang::Geometric2D >( instanceSelf ), true ); /* true means constant */
1008
1009 //       RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects( new std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > );
1010 //       instanceSelf->parents = createdObjects;
1011
1012 //       for( std::set< RefCountPtr< const Lang::Class > >::const_iterator i = multiParents.begin( ); i != multiParents.end( ); ++i )
1013 //               {
1014 //                       (*i)->superNew( instanceSelf, createdObjects, EMPTY_ARGLIST, evalState );
1015 //               }
1016
1017 //       args.mergeWithFormals( formals )
1018 //       Kernel::PassedEnv initEnv = new Kernel::Environment( theEnvironmentList, env, formals->formals->argumentOrder, args.orderedArguments );
1019
1020 //       {
1021 //               typedef std::list< std::pair< RefCountPtr< const Lang::Class >, const Ast::ArgListExprs * > > ListType;
1022 //               for( ListType::const_iterator i = parents->begin( ); i != parents->end( ); ++i )
1023 //                       {
1024 //                               RefCountPtr< Kernel::Arguments > superArgs( new Kernel::Arguments( true ) );   /* true means constant */
1025 //                               i->second->evaluate( superArgs, dstgroup, pdfo, metaState, initEnv );
1026 //                               i->first->superNew( instanceSelf, createdObjects, *superArgs, evalState );
1027 //                       }
1028 //       }
1029
1030 //       classExpr->setupInstance( instanceEnv, privateEnv, dstgroup, pdfo, metaState, initEnv );
1031
1032 //       addOverrides( instanceSelf, privateEnv, dstgroup, pdfo, metaState );
1033
1034 //       instanceSelf->prepare( dstgroup, pdfo, metaState );
1035
1036 //       return RefCountPtr< const Lang::Geometric2D >( instanceSelf );
1037 }
1038
1039 bool
1040 Lang::UserClass::method_isa( RefCountPtr< const Lang::Class > T ) const
1041 {
1042         if( T == selfRef )
1043                 {
1044                         return true;
1045                 }
1046         return allParents.find( T ) != allParents.end( );
1047 }
1048
1049 void
1050 Lang::UserClass::findMultiplyInheritedClasses( std::set< RefCountPtr< Lang::Class > > * visited, std::set< RefCountPtr< Lang::Class > > * found ) const
1051 {
1052         throw Exceptions::NotImplemented( "UserClass::findMultiplyInheritedClasses" );
1053 }
1054
1055 void
1056 Lang::UserClass::assertMethodOverridable( const char * id, const RefCountPtr< const Lang::Class > & caller ) const
1057 {
1058         if( classExpr->isInPublicGetSet( id ) || classExpr->isInAbstractSet( id ) )
1059                 {
1060                         if( classExpr->isInFinalSet( id ) )
1061                                 {
1062                                         throw Exceptions::OverridingFinalMethod( caller, selfRef, id );
1063                                 }
1064                 }
1065         else
1066                 {
1067                         throw Exceptions::OverridingUndeclaredMethod( caller, selfRef, id );
1068                 }
1069 }
1070
1071 void
1072 Lang::UserClass::superNew( RefCountPtr< Lang::Instance > instanceSelf,
1073                                                                                                                         RefCountPtr< std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > > > createdObjects,
1074                                                                                                                         Kernel::Arguments & args,
1075                                                                                                                         Kernel::EvalState * evalState ) const
1076 {
1077         std::map< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > >::iterator i = createdObjects->find( selfRef );
1078         if( i != createdObjects->end( ) )
1079                 {
1080                         return;
1081                 }
1082
1083         throw Exceptions::NotImplemented( "UserClass::superNew" );
1084
1085 //       Kernel::PassedEnv instanceEnv( new Kernel::Environment( env ) );
1086 //       Kernel::PassedEnv privateEnv( new Kernel::Environment( instanceEnv ) );
1087
1088 //       privateEnv->define( classExpr->loc( ), SELF_ID, RefCountPtr< const Lang::Geometric2D >( instanceSelf ), true ); /* true means constant */
1089
1090 //       args.mergeWithFormals( formals )
1091 //       Kernel::PassedEnv initEnv = new Kernel::Environment( theEnvironmentList, env, formals->formals->argumentOrder, args.orderedArguments );
1092
1093 //       {
1094 //               typedef std::list< std::pair< RefCountPtr< const Lang::Class >, const Ast::ArgListExprs * > > ListType;
1095 //               for( ListType::const_iterator i = parents->begin( ); i != parents->end( ); ++i )
1096 //                       {
1097 //                               RefCountPtr< Kernel::Arguments > superArgs( new Kernel::Arguments( true ) );   /* true means constant */
1098 //                               i->second->evaluate( superArgs, dstgroup, pdfo, metaState, initEnv );
1099 //                               i->first->superNew( instanceSelf, createdObjects, *superArgs, evalState );
1100 //                       }
1101 //       }
1102
1103 //       classExpr->setupInstance( instanceEnv, privateEnv, dstgroup, pdfo, metaState, initEnv );
1104
1105 //       Lang::Instance * newObj = new Lang::Instance( instanceEnv, privateEnv, selfRef, true, evalState->dyn_ );
1106 //       newObj->parents = createdObjects;
1107 //       createdObjects->insert( i, pair< RefCountPtr< const Lang::Class >, RefCountPtr< Lang::Instance > >( selfRef, RefCountPtr< Lang::Instance >( newObj ) ) );
1108 }
1109
1110 void
1111 Lang::UserClass::findParents( std::set< RefCountPtr< const Lang::Class > > * _allParents, std::set< RefCountPtr< const Lang::Class > > * _multiParents ) const
1112 {
1113         Lang::Class::findParents( _allParents, _multiParents );
1114         typedef typeof immediateParents SetType;
1115         for( SetType::const_iterator i = immediateParents.begin( ); i != immediateParents.end( ); ++i )
1116                 {
1117                         (*i)->findParents( _allParents, _multiParents );
1118                 }
1119 }
1120
1121 bool
1122 Lang::UserClass::isRepeatableBase( ) const
1123 {
1124         return classExpr->isRepeatableBase( );
1125 }
1126
1127 void
1128 Lang::UserClass::prepareInstance( Kernel::EvalState * evalState, Kernel::PassedEnv privateEnv ) const
1129 {
1130         classExpr->prepareInstance( evalState, privateEnv );
1131 }
1132
1133
1134 bool
1135 Lang::UserClass::isInPublicGetSet( const char * field ) const
1136 {
1137         return classExpr->isInPublicGetSet( field );
1138 }
1139
1140 bool
1141 Lang::UserClass::isInPublicSetSet( const char * field ) const
1142 {
1143         return classExpr->isInPublicSetSet( field );
1144 }
1145
1146 bool
1147 Lang::UserClass::isInProtectedGetSet( const char * field ) const
1148 {
1149         return classExpr->isInProtectedGetSet( field );
1150 }
1151
1152 bool
1153 Lang::UserClass::isInProtectedSetSet( const char * field ) const
1154 {
1155         return classExpr->isInProtectedSetSet( field );
1156 }
1157
1158 bool
1159 Lang::UserClass::isInTransformingSet( const char * field ) const
1160 {
1161         return classExpr->isInTransformingSet( field );
1162 }
1163
1164
1165 void
1166 Lang::UserClass::addOverrides( Kernel::EvalState * evalState, RefCountPtr< Lang::Instance > instance, Kernel::PassedEnv privateEnv ) const
1167 {
1168         typedef typeof *overrides DefMapType;
1169         for( DefMapType::const_iterator i = overrides->begin( ); i != overrides->end( ); ++i )
1170                 {
1171                         typedef std::map< const char *, RefCountPtr< const Lang::Function >, charPtrLess > InstanceMapType;
1172                         InstanceMapType & instanceMap = instance->overrides[ i->first ];
1173                         typedef typeof i->second DefListType;
1174                         InstanceMapType::iterator lastInsert = instanceMap.begin( );
1175                         for( DefListType::const_iterator j = i->second.begin( ); j != i->second.end( ); ++j )
1176                                 {
1177                                         throw Exceptions::NotImplemented( "addOverrides" );
1178 //                                       RefCountPtr< const Lang::Value > untypedMethod = (*j)->init->value( dstgroup, pdfo, metaState, privateEnv );
1179 //                                       typedef const Lang::Function FunType;
1180 //                                       RefCountPtr< FunType > typedMethod = untypedMethod.down_cast< FunType >( );
1181 //                                       if( typedMethod == NullPtr< FunType >( ) )
1182 //                                               {
1183 //                                                       throw Exceptions::TypeMismatch( (*j)->init, untypedMethod->getTypeName( ), FunType::staticTypeName( ) );
1184 //                                               }
1185 //                                       lastInsert = instanceMap.insert( lastInsert, InstanceMapType::value_type( (*j)->id, typedMethod ) );
1186                                 }
1187                 }
1188 }
1189
1190 void
1191 Lang::UserClass::gcMark( Kernel::GCMarkedSet & marked )
1192 {
1193         throw Exceptions::NotImplemented( "UserClass::gcMark" );
1194 }
1195
1196
1197
1198
1199 Lang::ClassMethodBase::ClassMethodBase( RefCountPtr< const Lang::Class > _self )
1200         : Lang::Function( 0 ), self( _self )
1201 {
1202         std::cerr << "Warning: Lang::ClassMethodBase::ClassMethodBase initializes Lang::Function with 0 pointer to formals." << std::endl ;
1203 }
1204
1205 Lang::ClassMethodBase::~ClassMethodBase( )
1206 { }
1207
1208 void
1209 Lang::ClassMethodBase::gcMark( Kernel::GCMarkedSet & marked )
1210 {
1211         const_cast< Lang::Class * >( self.getPtr( ) )->gcMark( marked );
1212 }
1213
1214 bool
1215 Lang::ClassMethodBase::isTransforming( ) const
1216 {
1217         return false;
1218 }
1219
1220 Lang::ClassMethodNew::ClassMethodNew( RefCountPtr< const Lang::Class > _self )
1221         : Lang::ClassMethodBase( _self )
1222 { }
1223
1224 void
1225 Lang::ClassMethodNew::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1226 {
1227         self->method_new( evalState, args, callLoc );
1228 }
1229
1230 Lang::ClassMethodIsa::ClassMethodIsa( RefCountPtr< const Lang::Class > _self )
1231         : Lang::ClassMethodBase( _self )
1232 { }
1233
1234 void
1235 Lang::ClassMethodIsa::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1236 {
1237         const size_t ARITY = 1;
1238         CHECK_ARITY( args, ARITY, Kernel::MethodId( Lang::Class::TypeID, "isa" ).prettyName( ) );
1239
1240         typedef const Lang::Class ArgType;
1241         RefCountPtr< ArgType > T = args.getValue( 0 ).down_cast< ArgType >( );
1242         if( T == NullPtr< ArgType >( ) )
1243                 {
1244                         throw Exceptions::CoreTypeMismatch( callLoc, Kernel::MethodId( Lang::Class::TypeID, "isa" ).prettyName( ), args, 0, ArgType::staticTypeName( ) );
1245                 }
1246
1247         Kernel::ContRef cont = evalState->cont_;
1248         cont->takeValue( Kernel::ValueRef( new Lang::Boolean( self->method_isa( T ) ) ),
1249                                                                          evalState );
1250 }