source/shapesexceptions.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, 2009 Henrik Tidefelt
  17  */
  18
  19 #include "shapesexceptions.h"
  20 #include "ast.h"
  21 #include "astclass.h"
  22 #include "globals.h"
  23 #include "functiontypes.h"
  24
  25 using namespace Shapes;
  26 using namespace std;
  27
  28
  29 const std::string Exceptions::additionalLinesPrefix = "| ";
  30
  31 namespace Shapes
  32 {
  33         namespace Exceptions
  34         {
  35                 void prefixEachLine( const std::string & prefix, std::istream & src, std::ostream & dst );
  36                 void prefixEachLine( const std::string & prefix, const RefCountPtr< const char > & src, std::ostream & dst );
  37         }
  38 }
  39
  40 Exceptions::NotImplemented::NotImplemented( const char * _functionality )
  41         : functionality( _functionality )
  42 { }
  43
  44 Exceptions::NotImplemented::~NotImplemented( )
  45 { }
  46
  47 void
  48 Exceptions::NotImplemented::display( std::ostream & os ) const
  49 {
  50         os << "Under construction: " << functionality << " is not implemented." << std::endl ;
  51 }
  52
  53 const char * Exceptions::Exception::locsep = ": ";
  54
  55 Exceptions::Exception::Exception( )
  56 { }
  57
  58 Exceptions::Exception::~Exception( )
  59 { }
  60
  61 Exceptions::MiscellaneousRequirement::MiscellaneousRequirement( RefCountPtr< const char > msg )
  62         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg.getPtr( ) ), msgMem_( msg )
  63 { }
  64
  65 Exceptions::MiscellaneousRequirement::MiscellaneousRequirement( const char * msg )
  66         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg ), msgMem_( NullPtr< const char >( ) )
  67 { }
  68
  69 Exceptions::MiscellaneousRequirement::~MiscellaneousRequirement( )
  70 { }
  71
  72 void
  73 Exceptions::MiscellaneousRequirement::display( ostream & os ) const
  74 {
  75         os << "Failed to meet requirement: " << msg_ << std::endl ;
  76 }
  77
  78 RefCountPtr< const Lang::Exception >
  79 Exceptions::MiscellaneousRequirement::clone( const Kernel::ContRef & cont ) const
  80 {
  81         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
  82         std::ostringstream os;
  83         display( os );
  84         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
  85                                                                                                                                                                                                                                                                                 kind,
  86                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core, generic)", true ) ),
  87                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
  88                                                                                                                                                                                                                                                                                 strrefdup( os ),
  89                                                                                                                                                                                                                                                                                 cont,
  90                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
  91 }
  92
  93
  94 Exceptions::HandlerError::HandlerError( RefCountPtr< const char > _msg )
  95         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg( _msg )
  96 { }
  97
  98 Exceptions::HandlerError::HandlerError( const char * _msg )
  99         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg( strrefdup( _msg ) )
 100 { }
 101
 102 Exceptions::HandlerError::~HandlerError( )
 103 { }
 104
 105 void
 106 Exceptions::HandlerError::display( ostream & os ) const
 107 {
 108         os << "Error handler message: " << msg << std::endl ;
 109 }
 110
 111 RefCountPtr< const Lang::Exception >
 112 Exceptions::HandlerError::clone( const Kernel::ContRef & cont ) const
 113 {
 114         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
 115         std::ostringstream os;
 116         display( os );
 117         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 118                                                                                                                                                                                                                                                                                 kind,
 119                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(default error handler)", true ) ),
 120                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
 121                                                                                                                                                                                                                                                                                 strrefdup( os ),
 122                                                                                                                                                                                                                                                                                 cont,
 123                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 124 }
 125
 126
 127 Exceptions::MiscellaneousStaticInconsistency::MiscellaneousStaticInconsistency( const Ast::SourceLocation & loc, RefCountPtr< const char > _msg )
 128         : Exceptions::StaticInconsistency( loc ), msg( _msg )
 129 { }
 130
 131 Exceptions::MiscellaneousStaticInconsistency::~MiscellaneousStaticInconsistency( )
 132 { }
 133
 134 void
 135 Exceptions::MiscellaneousStaticInconsistency::display( ostream & os ) const
 136 {
 137         os << "Misc error: " << msg << std::endl ;
 138 }
 139
 140
 141 Exceptions::ScannerError::ScannerError( const Ast::SourceLocation & loc, RefCountPtr< const char > _msg )
 142         : Exceptions::StaticInconsistency( loc ), msg( _msg )
 143 { }
 144
 145 Exceptions::ScannerError::~ScannerError( )
 146 { }
 147
 148 void
 149 Exceptions::ScannerError::display( ostream & os ) const
 150 {
 151         os << "Scanner error: " << msg << std::endl ;
 152 }
 153
 154
 155 Exceptions::ParserError::ParserError( const Ast::SourceLocation & loc_, RefCountPtr< const char > msg, bool justAWarning )
 156         : Exceptions::StaticInconsistency( loc_ ), msg_( msg ), justAWarning_( justAWarning )
 157 { }
 158
 159 Exceptions::ParserError::~ParserError( )
 160 { }
 161
 162 void
 163 Exceptions::ParserError::display( ostream & os ) const
 164 {
 165         os << "Parser " << ( justAWarning_ ? "warning" : "error" ) << ": " << msg_ << std::endl ;
 166 }
 167
 168
 169 Exceptions::MemberAlsoAbstract::MemberAlsoAbstract( const Ast::SourceLocation & _memberLoc, const char * _id, const Ast::SourceLocation & _abstractLoc )
 170         : Exceptions::StaticInconsistency( _memberLoc ), memberLoc( _memberLoc ), id( _id ), abstractLoc( _abstractLoc )
 171 { }
 172
 173 Exceptions::MemberAlsoAbstract::~MemberAlsoAbstract( )
 174 { }
 175
 176 void
 177 Exceptions::MemberAlsoAbstract::display( ostream & os ) const
 178 {
 179         os << "The member " << id << " is also declared abstract, at " << abstractLoc << "." << std::endl ;
 180 }
 181
 182
 183 Exceptions::MemberAlreadyDeclared::MemberAlreadyDeclared( const Ast::SourceLocation & _memberLoc, const char * _id, const Ast::SourceLocation & _oldLoc )
 184         : Exceptions::StaticInconsistency( _memberLoc ), memberLoc( _memberLoc ), id( _id ), oldLoc( _oldLoc )
 185 { }
 186
 187 Exceptions::MemberAlreadyDeclared::~MemberAlreadyDeclared( )
 188 { }
 189
 190 void
 191 Exceptions::MemberAlreadyDeclared::display( ostream & os ) const
 192 {
 193         os << "The member " << id << " has already been declared, at " << oldLoc << "." << std::endl ;
 194 }
 195
 196
 197 Exceptions::PublicGetSetInNonfinalClass::PublicGetSetInNonfinalClass( const Ast::SourceLocation & _memberLoc, const char * _id )
 198         : Exceptions::StaticInconsistency( _memberLoc ), memberLoc( _memberLoc ), id( _id )
 199 { }
 200
 201 Exceptions::PublicGetSetInNonfinalClass::~PublicGetSetInNonfinalClass( )
 202 { }
 203
 204 void
 205 Exceptions::PublicGetSetInNonfinalClass::display( ostream & os ) const
 206 {
 207         os << "Only members of final classes may have the public get or set specifier.  Member in question: " << id << "." << std::endl ;
 208 }
 209
 210
 211 Exceptions::TransformingMemberInNonfinalClass::TransformingMemberInNonfinalClass( const Ast::SourceLocation & _memberLoc, const char * _id )
 212         : Exceptions::StaticInconsistency( _memberLoc ), memberLoc( _memberLoc ), id( _id )
 213 { }
 214
 215 Exceptions::TransformingMemberInNonfinalClass::~TransformingMemberInNonfinalClass( )
 216 { }
 217
 218 void
 219 Exceptions::TransformingMemberInNonfinalClass::display( ostream & os ) const
 220 {
 221         os << "Only members of final classes may have the <transforming> specifier.     Member in question: " << id << "." << std::endl ;
 222 }
 223
 224
 225 Exceptions::RepeatedFormal::RepeatedFormal( const Ast::SourceLocation & loc, const char * _id )
 226         : Exceptions::StaticInconsistency( loc ), id( _id )
 227 { }
 228
 229 Exceptions::RepeatedFormal::~RepeatedFormal( )
 230 { }
 231
 232 void
 233 Exceptions::RepeatedFormal::display( ostream & os ) const
 234 {
 235         os << "Repeated formal: " << id << std::endl ;
 236 }
 237
 238
 239 Exceptions::IllegalFreeStates::IllegalFreeStates( const Ast::SourceLocation & loc, Ast::StateIDSet * freeStates, const char * reason )
 240         : Exceptions::StaticInconsistency( loc ), freeStates_( freeStates ), reason_( reason )
 241 { }
 242
 243 Exceptions::IllegalFreeStates::~IllegalFreeStates( )
 244 { }
 245
 246 void
 247 Exceptions::IllegalFreeStates::display( ostream & os ) const
 248 {
 249         os << "Free states are illegal here (" << reason_ << "):" ;
 250         typedef typeof *freeStates_ SetType;
 251         for( SetType::const_iterator i = freeStates_->begin( ); i != freeStates_->end( ); ++i )
 252                 {
 253                         os << " " << *i ;
 254                 }
 255         os << std::endl ;
 256 }
 257
 258
 259 Exceptions::FreeStateIsAlsoPassed::FreeStateIsAlsoPassed( const Ast::SourceLocation & loc, Ast::StateID stateID )
 260         : Exceptions::StaticInconsistency( loc ), stateID_( stateID )
 261 { }
 262
 263 Exceptions::FreeStateIsAlsoPassed::~FreeStateIsAlsoPassed( )
 264 { }
 265
 266 void
 267 Exceptions::FreeStateIsAlsoPassed::display( ostream & os ) const
 268 {
 269         os << "Non-pure, delayed, expressions may not have free states which are also passed as state arguments in the same non-pure function application.  Please consider forcing immediate evaluation." << std::endl ;
 270 }
 271
 272
 273 Exceptions::RepeatedStateArgument::RepeatedStateArgument( const Ast::SourceLocation & loc, const RefCountPtr< Ast::StateIDSet > & passedStates )
 274         : Exceptions::StaticInconsistency( loc ), passedStates_( passedStates )
 275 { }
 276
 277 Exceptions::RepeatedStateArgument::~RepeatedStateArgument( )
 278 { }
 279
 280 void
 281 Exceptions::RepeatedStateArgument::display( ostream & os ) const
 282 {
 283         os << "Some of these states are being passed in more than one state argument position:" ;
 284         typedef typeof *passedStates_ SetType;
 285         for( SetType::const_iterator i = passedStates_->begin( ); i != passedStates_->end( ); ++i )
 286                 {
 287                         os << " " << *i ;
 288                 }
 289         os << std::endl ;
 290 }
 291
 292
 293 Exceptions::PassingStateOut::PassingStateOut( const Ast::SourceLocation & loc, const char * id )
 294         : Exceptions::StaticInconsistency( loc ), id_( id )
 295 { }
 296
 297 Exceptions::PassingStateOut::~PassingStateOut( )
 298 { }
 299
 300 void
 301 Exceptions::PassingStateOut::display( std::ostream & os ) const
 302 {
 303         os << "States may not be returned." << std::endl ;
 304 }
 305
 306
 307 Exceptions::IntroducingExisting::IntroducingExisting( const Ast::SourceLocation & _loc, const char * _id )
 308         : Exceptions::StaticInconsistency( _loc ), loc( _loc ), id( _id )
 309 { }
 310
 311 Exceptions::IntroducingExisting::~IntroducingExisting( )
 312 { }
 313
 314 void
 315 Exceptions::IntroducingExisting::display( std::ostream & os ) const
 316 {
 317         os << "The variable " << id << " is already introduced in this scope." << std::endl ;
 318 }
 319
 320
 321 Exceptions::ExpectedImmediate::ExpectedImmediate( const Ast::SourceLocation & _loc )
 322         : Exceptions::StaticInconsistency( _loc ), loc( _loc )
 323 { }
 324
 325 Exceptions::ExpectedImmediate::~ExpectedImmediate( )
 326 { }
 327
 328 void
 329 Exceptions::ExpectedImmediate::display( std::ostream & os ) const
 330 {
 331         os << "It makes no sense to put a pure expression before the end of a code bracket." << std::endl ;
 332 }
 333
 334
 335 Exceptions::IllegalImperative::IllegalImperative( const Ast::SourceLocation & _loc )
 336         : Exceptions::StaticInconsistency( _loc ), loc( _loc )
 337 { }
 338
 339 Exceptions::IllegalImperative::~IllegalImperative( )
 340 { }
 341
 342 void
 343 Exceptions::IllegalImperative::display( std::ostream & os ) const
 344 {
 345         os << "Imperative expressions are not allowed here." << std::endl ;
 346 }
 347
 348
 349 Exceptions::FreezingUndefined::FreezingUndefined( const Ast::SourceLocation & _loc, const char * _id )
 350         : Exceptions::StaticInconsistency( _loc ), loc( _loc ), id( _id )
 351 { }
 352
 353 Exceptions::FreezingUndefined::~FreezingUndefined( )
 354 { }
 355
 356 void
 357 Exceptions::FreezingUndefined::display( std::ostream & os ) const
 358 {
 359         os << "Internal error:  The variable " << id << " is freezed before it was defined.     Either this should be caught by during the parse, or it is due to an error in the setup of the initial environment." << std::endl ;
 360 }
 361
 362
 363 Exceptions::FileReadOpenError::FileReadOpenError( const Ast::SourceLocation & _loc, RefCountPtr< const char > _filename, const std::string * sourceDir, const std::list< std::string > * searchPath, Type _type )
 364         : loc( _loc ), filename( _filename ), type( _type ), sourceDir_( sourceDir ), searchPath_( searchPath )
 365 { }
 366
 367 Exceptions::FileReadOpenError::~FileReadOpenError( )
 368 { }
 369
 370 void
 371 Exceptions::FileReadOpenError::display( std::ostream & os ) const
 372 {
 373         switch( type )
 374                 {
 375                 case OPEN:
 376                         os << loc << locsep << "Could not open file: " << filename ;
 377                         break;
 378                 case STAT:
 379                         os << loc << locsep << "Could not stat() file: " << filename ;
 380                         break;
 381                 default:
 382                         os << loc << locsep << "Internal error when displaying FileReadOpenError on file: " << filename ;
 383                 }
 384         if( searchPath_ != 0 )
 385                 {
 386                         os << " searching \"" ;
 387                         typedef typeof *searchPath_ ListType;
 388                         for( ListType::const_iterator i = searchPath_->begin( ); i != searchPath_->end( ); ++i )
 389                                 {
 390                                         if( i != searchPath_->begin( ) )
 391                                                 {
 392                                                         os << ":" ;
 393                                                 }
 394                                         if( sourceDir_ != 0 && (*i)[0] != '/' )
 395                                                 {
 396                                                         os << *sourceDir_ ;
 397                                                 }
 398                                         os << *i ;
 399                                 }
 400                         os << "\"" ;
 401                 }
 402         os << std::endl ;
 403 }
 404
 405
 406 Exceptions::FileWriteOpenError::FileWriteOpenError( const Ast::SourceLocation & _loc, RefCountPtr< const char > _filename, const char * purpose )
 407         : loc( _loc ), filename( _filename ), purpose_( purpose )
 408 { }
 409
 410 Exceptions::FileWriteOpenError::~FileWriteOpenError( )
 411 { }
 412
 413 void
 414 Exceptions::FileWriteOpenError::display( std::ostream & os ) const
 415 {
 416         os << loc << locsep << "Could not open " ;
 417         if( purpose_ != 0 )
 418                 {
 419                         os << purpose_ ;
 420                 }
 421         os << " file for write: " << filename ;
 422         os << std::endl ;
 423 }
 424
 425
 426 Exceptions::TeXSetupTooLate::TeXSetupTooLate( const Ast::SourceLocation & _loc )
 427         : loc( _loc )
 428 { }
 429
 430 Exceptions::TeXSetupTooLate::~TeXSetupTooLate( )
 431 { }
 432
 433 void
 434 Exceptions::TeXSetupTooLate::display( std::ostream & os ) const
 435 {
 436         os << loc << locsep << "It is too late to make modifications to the TeX context." << std::endl ;
 437 }
 438
 439
 440 Exceptions::EmptyFinalPicture::EmptyFinalPicture( )
 441 { }
 442
 443 Exceptions::EmptyFinalPicture::~EmptyFinalPicture( )
 444 { }
 445
 446 void
 447 Exceptions::EmptyFinalPicture::display( std::ostream & os ) const
 448 {
 449         os << "Nothing was ever put in the global #" << Lang::CATALOG_ID << " or drawn to the global #" << Lang::CANVAS_ID << "." << std::endl ;
 450 }
 451
 452
 453 Exceptions::TeXSetupHasChanged::TeXSetupHasChanged( )
 454         : Shapes::Exceptions::InternalError( "The TeX context check failed while loading fresh labels." )
 455 { }
 456
 457 Exceptions::TeXSetupHasChanged::~TeXSetupHasChanged( )
 458 { }
 459
 460
 461 Exceptions::TypeMismatch::TypeMismatch( const Ast::SourceLocation & loc, RefCountPtr< const char > _valueType, RefCountPtr< const char > _expectedType )
 462         : Exceptions::RuntimeError( loc ), hint_( 0 ), valueType( _valueType ), expectedType( _expectedType )
 463 { }
 464
 465 Exceptions::TypeMismatch::TypeMismatch( const Ast::SourceLocation & loc, const char * hint, RefCountPtr< const char > _valueType, RefCountPtr< const char > _expectedType )
 466         : Exceptions::RuntimeError( loc ), hint_( hint ), valueType( _valueType ), expectedType( _expectedType )
 467 { }
 468
 469 Exceptions::TypeMismatch::~TypeMismatch( )
 470 { }
 471
 472 void
 473 Exceptions::TypeMismatch::display( std::ostream & os ) const
 474 {
 475         if( hint_ != 0 )
 476                 {
 477                         os << hint_ << ": " ;
 478                 }
 479         os << "Expected a " << expectedType << ", got a " << valueType << "." << std::endl ;
 480 }
 481
 482 Exceptions::PDFVersionError::PDFVersionError( SimplePDF::PDF_Version::Version version, SimplePDF::PDF_Version::Version required, const RefCountPtr< const char > & msg, bool justAWarning )
 483         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), version_( version ), required_( required ), msgMem_( msg ), msg_( msgMem_.getPtr( ) ), justAWarning_( justAWarning )
 484 { }
 485
 486 Exceptions::PDFVersionError::PDFVersionError( SimplePDF::PDF_Version::Version version, SimplePDF::PDF_Version::Version required, const char * msg, bool justAWarning )
 487         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), version_( version ), required_( required ), msgMem_( NullPtr< const char >( ) ), msg_( msg ), justAWarning_( justAWarning )
 488 { }
 489
 490 Exceptions::PDFVersionError::~PDFVersionError( )
 491 { }
 492
 493 void
 494 Exceptions::PDFVersionError::display( std::ostream & os ) const
 495 {
 496         os << SimplePDF::PDF_Version::toString( required_ ) << " " << ( justAWarning_ ? "warning" : "error" ) << ": " << msg_ << std::endl ;
 497 }
 498
 499 RefCountPtr< const Lang::Exception >
 500 Exceptions::PDFVersionError::clone( const Kernel::ContRef & cont ) const
 501 {
 502         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "PDF_version" ) );
 503         std::ostringstream os;
 504         display( os );
 505         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 506                                                                                                                                                                                                                                                                                 kind,
 507                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core PDF backend)", true ) ),
 508                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
 509                                                                                                                                                                                                                                                                                 strrefdup( os ),
 510                                                                                                                                                                                                                                                                                 cont,
 511                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 512 }
 513
 514
 515 Exceptions::RedefiningLexical::RedefiningLexical( const char * _id )
 516         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), id( _id )
 517 { }
 518
 519 Exceptions::RedefiningLexical::~RedefiningLexical( )
 520 { }
 521
 522 void
 523 Exceptions::RedefiningLexical::display( std::ostream & os ) const
 524 {
 525         os << "Redefining " << id << std::endl ;
 526 }
 527
 528
 529 Exceptions::RedefiningDynamic::RedefiningDynamic( const char * _id )
 530         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), id( _id )
 531 { }
 532
 533 Exceptions::RedefiningDynamic::~RedefiningDynamic( )
 534 { }
 535
 536 void
 537 Exceptions::RedefiningDynamic::display( std::ostream & os ) const
 538 {
 539         os << "Redefining " << "@" << id << std::endl ;
 540 }
 541
 542
 543 Exceptions::NonObjectMemberAssignment::NonObjectMemberAssignment( const Ast::SourceLocation & _loc, RefCountPtr< const char > _valueType )
 544         : Exceptions::RuntimeError( _loc ), valueType( _valueType )
 545 { }
 546
 547 Exceptions::NonObjectMemberAssignment::~NonObjectMemberAssignment( )
 548 { }
 549
 550 void
 551 Exceptions::NonObjectMemberAssignment::display( std::ostream & os ) const
 552 {
 553         os << "Only object oriented values have fields that can be assigned.    This value is of type " << valueType << "." << std::endl ;
 554 }
 555
 556
 557 Exceptions::ElementaryWithout::ElementaryWithout( Kind kind, Ref ref, RefCountPtr< const char > _valueType )
 558         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), kind_( kind ), ref_( ref ), valueType( _valueType )
 559 { }
 560
 561 Exceptions::ElementaryWithout::~ElementaryWithout( )
 562 { }
 563
 564 void
 565 Exceptions::ElementaryWithout::display( std::ostream & os ) const
 566 {
 567         os << "This " ;
 568         switch( kind_ )
 569                 {
 570                 case VALUE:
 571                         os << "value" ;
 572                         break;
 573                 case STATE:
 574                         os << "state" ;
 575                         break;
 576                 }
 577         os << " is of the elementary type " << valueType << ", which has no " ;
 578         switch( ref_ )
 579                 {
 580                 case FIELD:
 581                         os << "fields" ;
 582                         break;
 583                 case MUTATOR:
 584                         os << "mutators" ;
 585                         break;
 586                 }
 587                 os << "." << std::endl ;
 588 }
 589
 590
 591 Exceptions::NonExistentPosition::NonExistentPosition( size_t pos, size_t maxPos )
 592         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), pos_( pos ), maxPos_( maxPos )
 593 { }
 594
 595 Exceptions::NonExistentPosition::~NonExistentPosition( )
 596 { }
 597
 598 void
 599 Exceptions::NonExistentPosition::display( std::ostream & os ) const
 600 {
 601         os << "Referencing field at position " << pos_ << " is an error since the user struct has only " << maxPos_ << " ordered fields." << std::endl ;
 602 }
 603
 604
 605 Exceptions::UnaryPrefixNotApplicable::UnaryPrefixNotApplicable( const Ast::SourceLocation & _loc, const Ast::Expression * _expr, RefCountPtr< const char > _valueType )
 606         : Exceptions::RuntimeError( _loc ), expr( _expr ), valueType( _valueType ), operatorSymbol( "< ? >" )
 607 { }
 608
 609 Exceptions::UnaryPrefixNotApplicable::~UnaryPrefixNotApplicable( )
 610 { }
 611
 612 void
 613 Exceptions::UnaryPrefixNotApplicable::setOperatorSymbol( const char * _operatorSymbol )
 614 {
 615         operatorSymbol = _operatorSymbol;
 616 }
 617
 618 void
 619 Exceptions::UnaryPrefixNotApplicable::display( std::ostream & os ) const
 620 {
 621         if( expr != 0 )
 622                 {
 623                         os << "Operator " ;
 624                         getLoc( ).copy( & os );
 625                         os << " not defined for " << valueType << " at " << expr->loc( ) << "." << std::endl ;
 626                 }
 627         else
 628                 {
 629                         os << "Operator " << operatorSymbol << " not defined for " << valueType << "." << std::endl ;
 630                 }
 631 }
 632
 633
 634 Exceptions::UnaryPostfixNotApplicable::UnaryPostfixNotApplicable( const Ast::SourceLocation & _loc, const Ast::Expression * _expr, RefCountPtr< const char > _valueType )
 635         : Exceptions::RuntimeError( _loc ), expr( _expr ), valueType( _valueType ), operatorSymbol( "< ? >" )
 636 { }
 637
 638 Exceptions::UnaryPostfixNotApplicable::~UnaryPostfixNotApplicable( )
 639 { }
 640
 641 void
 642 Exceptions::UnaryPostfixNotApplicable::setOperatorSymbol( const char * _operatorSymbol )
 643 {
 644         operatorSymbol = _operatorSymbol;
 645 }
 646
 647 void
 648 Exceptions::UnaryPostfixNotApplicable::display( std::ostream & os ) const
 649 {
 650         if( expr != 0 )
 651                 {
 652                         os << "Operator " ;
 653                         getLoc( ).copy( & os );
 654                         os << " not defined for " << valueType << " at " << expr->loc( ) << "." << std::endl ;
 655                 }
 656         else
 657                 {
 658                         os << "Operator " << operatorSymbol << " not defined for " << valueType << "." << std::endl ;
 659                 }
 660 }
 661
 662
 663 Exceptions::BinaryInfixNotApplicable::BinaryInfixNotApplicable( const Ast::SourceLocation & _loc, const Ast::Expression * _expr1, RefCountPtr< const char > _valueType1, const Ast::Expression * _expr2, RefCountPtr< const char > _valueType2 )
 664         : Exceptions::RuntimeError( _loc ), expr1( _expr1 ), valueType1( _valueType1 ), expr2( _expr2 ), valueType2( _valueType2 ), operatorSymbol( "< ? >" )
 665 { }
 666
 667 Exceptions::BinaryInfixNotApplicable::~BinaryInfixNotApplicable( )
 668 { }
 669
 670 void
 671 Exceptions::BinaryInfixNotApplicable::setOperatorSymbol( const char * _operatorSymbol )
 672 {
 673         operatorSymbol = _operatorSymbol;
 674 }
 675
 676 void
 677 Exceptions::BinaryInfixNotApplicable::display( std::ostream & os ) const
 678 {
 679         if( expr1 != 0 && expr2 != 0 )
 680                 {
 681                         os << "Operator " ;
 682                         getLoc( ).copy( & os );
 683                         os << " not defined for (" << valueType1 << "," << valueType2 << ") at " << expr1->loc( ) << ", " << expr2->loc( ) << "." << std::endl ;
 684                 }
 685         else
 686                 {
 687                         os << "Operator " << operatorSymbol << " not defined for (" << valueType1 << "," << valueType2 << ")." << std::endl ;
 688                 }
 689 }
 690
 691
 692 Exceptions::LookupUnknown::LookupUnknown( const Ast::SourceLocation & _loc, RefCountPtr< const char > _id, Type type )
 693         : Exceptions::StaticInconsistency( _loc ), id( _id ), type_( type )
 694 { }
 695
 696 Exceptions::LookupUnknown::~LookupUnknown( )
 697 { }
 698
 699 void
 700 Exceptions::LookupUnknown::display( std::ostream & os ) const
 701 {
 702         switch( type_ )
 703                 {
 704                 case VARIABLE:
 705                         os << "The variable " << id << " is unbound." << std::endl ;
 706                         break;
 707                 case STATE:
 708                         os << "There is no state called " << id << " around." << std::endl ;
 709                         break;
 710                 case DYNAMIC_VARIABLE:
 711                         os << "There is no dynamic variable called " << id << " around." << std::endl ;
 712                         break;
 713                 case DYNAMIC_STATE:
 714                         os << "There is no dynamic state called " << id << " around." << std::endl ;
 715                         break;
 716                 case TYPE:
 717                         os << "There is no type called " << id << " around." << std::endl ;
 718                         break;
 719                 default:
 720                         os << "<?ERROR?" ;
 721                 }
 722 }
 723
 724
 725 Exceptions::StateBeyondFunctionBoundary::StateBeyondFunctionBoundary( const Ast::SourceLocation & _loc, RefCountPtr< const char > _id )
 726         : Exceptions::StaticInconsistency( _loc ), id( _id )
 727 { }
 728
 729 Exceptions::StateBeyondFunctionBoundary::~StateBeyondFunctionBoundary( )
 730 { }
 731
 732 void
 733 Exceptions::StateBeyondFunctionBoundary::display( std::ostream & os ) const
 734 {
 735         os << "The state " << id << " resides outside a function boundary." << std::endl ;
 736 }
 737
 738
 739 Exceptions::IntroducingExistingUnit::IntroducingExistingUnit( const Ast::SourceLocation & _loc, RefCountPtr< const char > _id )
 740         : Exceptions::StaticInconsistency( _loc ), id( _id )
 741 { }
 742
 743 Exceptions::IntroducingExistingUnit::~IntroducingExistingUnit( )
 744 { }
 745
 746 void
 747 Exceptions::IntroducingExistingUnit::display( std::ostream & os ) const
 748 {
 749         os << "Inconsistent definition of the existing unit " << id << "." << std::endl ;
 750 }
 751
 752
 753 Exceptions::LookupUnknownUnit::LookupUnknownUnit( const Ast::SourceLocation & _loc, RefCountPtr< const char > _id )
 754         : Exceptions::StaticInconsistency( _loc ), id( _id )
 755 { }
 756
 757 Exceptions::LookupUnknownUnit::~LookupUnknownUnit( )
 758 { }
 759
 760 void
 761 Exceptions::LookupUnknownUnit::display( std::ostream & os ) const
 762 {
 763         os << "The unit " << id << " is unbound" << std::endl ;
 764 }
 765
 766
 767 Exceptions::OutOfRange::OutOfRange( RefCountPtr< const char > msg )
 768         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg.getPtr( ) ), msgMem_( msg )
 769 { }
 770
 771 Exceptions::OutOfRange::OutOfRange( const char * msg )
 772         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg ), msgMem_( NullPtr< const char >( ) )
 773 { }
 774
 775 Exceptions::OutOfRange::OutOfRange( const Ast::SourceLocation & _loc, RefCountPtr< const char > msg )
 776         : Exceptions::CatchableError( _loc ), msg_( msg.getPtr( ) ), msgMem_( msg )
 777 { }
 778
 779 Exceptions::OutOfRange::OutOfRange( const Ast::SourceLocation & _loc, const char * msg )
 780         : Exceptions::CatchableError( _loc ), msg_( msg ), msgMem_( NullPtr< const char >( ) )
 781 { }
 782
 783 Exceptions::OutOfRange::~OutOfRange( )
 784 { }
 785
 786 void
 787 Exceptions::OutOfRange::display( std::ostream & os ) const
 788 {
 789         os << "Out-of-range error: " << msg_ << std::endl ;
 790 }
 791
 792 RefCountPtr< const Lang::Exception >
 793 Exceptions::OutOfRange::clone( const Kernel::ContRef & cont ) const
 794 {
 795         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "out_of_range" ) );
 796         std::ostringstream os;
 797         display( os );
 798         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 799                                                                                                                                                                                                                                                                                 kind,
 800                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core, generic)", true ) ),
 801                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
 802                                                                                                                                                                                                                                                                                 strrefdup( os ),
 803                                                                                                                                                                                                                                                                                 cont,
 804                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 805 }
 806
 807
 808 Exceptions::FontProblem::FontProblem( const RefCountPtr< const Lang::Symbol > & PostScript_name, RefCountPtr< const char > msg, bool justAWarning )
 809         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), PostScript_name_( PostScript_name ), msg_( msg.getPtr( ) ), msgMem_( msg ), justAWarning_( justAWarning )
 810 { }
 811
 812 Exceptions::FontProblem::FontProblem( const RefCountPtr< const Lang::Symbol > & PostScript_name, const char * msg, bool justAWarning )
 813         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), PostScript_name_( PostScript_name ), msg_( msg ), msgMem_( NullPtr< const char >( ) ), justAWarning_( justAWarning )
 814 { }
 815
 816 Exceptions::FontProblem::FontProblem( const RefCountPtr< const Lang::Symbol > & PostScript_name, const Ast::SourceLocation & _loc, RefCountPtr< const char > msg, bool justAWarning )
 817         : Exceptions::CatchableError( _loc ), PostScript_name_( PostScript_name ), msg_( msg.getPtr( ) ), msgMem_( msg ), justAWarning_( justAWarning )
 818 { }
 819
 820 Exceptions::FontProblem::FontProblem( const RefCountPtr< const Lang::Symbol > & PostScript_name, const Ast::SourceLocation & _loc, const char * msg, bool justAWarning )
 821         : Exceptions::CatchableError( _loc ), PostScript_name_( PostScript_name ), msg_( msg ), msgMem_( NullPtr< const char >( ) ), justAWarning_( justAWarning )
 822 { }
 823
 824 Exceptions::FontProblem::~FontProblem( )
 825 { }
 826
 827 void
 828 Exceptions::FontProblem::display( std::ostream & os ) const
 829 {
 830         os << "Font " << ( justAWarning_ ? "warning" : "error" ) << " using " << PostScript_name_->name( ) << ": " << msg_ << std::endl ;
 831 }
 832
 833 RefCountPtr< const Lang::Exception >
 834 Exceptions::FontProblem::clone( const Kernel::ContRef & cont ) const
 835 {
 836         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
 837         std::ostringstream os;
 838         display( os );
 839         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 840                                                                                                                                                                                                                                                                                 kind,
 841                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(font problem)", true ) ),
 842                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
 843                                                                                                                                                                                                                                                                                 strrefdup( os ),
 844                                                                                                                                                                                                                                                                                 cont,
 845                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 846 }
 847
 848
 849 Exceptions::NonVoidStatement::NonVoidStatement( const Ast::SourceLocation & loc, RefCountPtr< const Lang::Value > val )
 850         : Exceptions::RuntimeError( loc ), val_( val )
 851 { }
 852
 853 Exceptions::NonVoidStatement::~NonVoidStatement( )
 854 { }
 855
 856 void
 857 Exceptions::NonVoidStatement::display( std::ostream & os ) const
 858 {
 859         os << "No implicit ignore of non-void value (of type " << val_->getTypeName( ) <<       ")" << std::endl ;
 860 }
 861
 862 // Exceptions::RuntimeError::RuntimeError( )
 863 //       : loc_( "< unlocated runtime error >" )
 864 // { }
 865
 866 Exceptions::RuntimeError::~RuntimeError( )
 867 { }
 868
 869 Exceptions::RuntimeError::RuntimeError( const Ast::SourceLocation & loc )
 870         : loc_( loc )
 871 { }
 872
 873 Exceptions::RuntimeError::RuntimeError( Ast::Expression * expr )
 874         : loc_( expr->loc( ) )
 875 { }
 876
 877 const Ast::SourceLocation &
 878 Exceptions::RuntimeError::getLoc( ) const
 879 {
 880         return loc_;
 881 }
 882
 883
 884 Exceptions::CatchableError::CatchableError( const Ast::SourceLocation & loc )
 885         : Exceptions::RuntimeError( loc )
 886 { }
 887
 888 Exceptions::CatchableError::CatchableError( Ast::Expression * expr )
 889         : Exceptions::RuntimeError( expr )
 890 { }
 891
 892 Exceptions::CatchableError::~CatchableError( )
 893 { }
 894
 895
 896 Exceptions::UncaughtError::UncaughtError( const RefCountPtr< const Lang::Exception > & ball )
 897         : Exceptions::RuntimeError( ball->loc( ) ), ball_( ball )
 898 { }
 899
 900 Exceptions::UncaughtError::~UncaughtError( )
 901 { }
 902
 903 void
 904 Exceptions::UncaughtError::display( std::ostream & os ) const
 905 {
 906         os << "Uncaught error: " ;
 907         ball_->show( os );
 908         os << std::endl ;
 909 }
 910
 911 Interaction::ExitCode
 912 Exceptions::UncaughtError::exitCode( ) const
 913 {
 914         return ball_->exitCode( );
 915 }
 916
 917
 918 Exceptions::UserError::UserError( const RefCountPtr< const Lang::Symbol > & kind, const RefCountPtr< const Lang::String > & source, const RefCountPtr< const Lang::Value > & details, const RefCountPtr< const char > & message )
 919         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), kind_( kind ), source_( source ), details_( details ), message_( message )
 920 { }
 921
 922 Exceptions::UserError::~UserError( )
 923 { }
 924
 925 void
 926 Exceptions::UserError::display( ostream & os ) const
 927 {
 928         os << "'" ;
 929         kind_->show( os );
 930         os << " error in " << source_->val_ << ": " << message_ << std::endl ;
 931 }
 932
 933 RefCountPtr< const Lang::Exception >
 934 Exceptions::UserError::clone( const Kernel::ContRef & cont ) const
 935 {
 936         std::ostringstream os;
 937         display( os );
 938         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 939                                                                                                                                                                                                                                                                                 kind_,
 940                                                                                                                                                                                                                                                                                 source_,
 941                                                                                                                                                                                                                                                                                 details_,
 942                                                                                                                                                                                                                                                                                 strrefdup( os ),
 943                                                                                                                                                                                                                                                                                 cont,
 944                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 945 }
 946
 947
 948 Exceptions::UserOutOfRange::UserOutOfRange( const RefCountPtr< const Lang::Symbol > & kind, const RefCountPtr< const Lang::String > & source, const RefCountPtr< const Lang::Integer > & details, const RefCountPtr< const char > & message )
 949         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), kind_( kind ), source_( source ), details_( details ), message_( message )
 950 { }
 951
 952 Exceptions::UserOutOfRange::~UserOutOfRange( )
 953 { }
 954
 955 void
 956 Exceptions::UserOutOfRange::display( ostream & os ) const
 957 {
 958         os << "In " << source_->val_ << ", argument " << details_->val_
 959                  << ", out-of-range: " << message_ << std::endl ;
 960 }
 961
 962 RefCountPtr< const Lang::Exception >
 963 Exceptions::UserOutOfRange::clone( const Kernel::ContRef & cont ) const
 964 {
 965         std::ostringstream os;
 966         display( os );
 967         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 968                                                                                                                                                                                                                                                                                 kind_,
 969                                                                                                                                                                                                                                                                                 source_,
 970                                                                                                                                                                                                                                                                                 details_,
 971                                                                                                                                                                                                                                                                                 strrefdup( os ),
 972                                                                                                                                                                                                                                                                                 cont,
 973                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
 974 }
 975
 976
 977 Exceptions::UserTypeMismatch::UserTypeMismatch( const RefCountPtr< const Lang::Symbol > & kind, const RefCountPtr< const Lang::String > & source, const RefCountPtr< const Lang::Integer > & details, const RefCountPtr< const char > & expectedType, const RefCountPtr< const char > & valueType )
 978         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), kind_( kind ), source_( source ), details_( details ), expectedType_( expectedType ), valueType_( valueType )
 979 { }
 980
 981 Exceptions::UserTypeMismatch::~UserTypeMismatch( )
 982 { }
 983
 984 void
 985 Exceptions::UserTypeMismatch::display( ostream & os ) const
 986 {
 987         os << "In " << source_->val_ << ", argument " << details_->val_
 988                  << ": expected a " << expectedType_ << ", got a " << valueType_ << "." << std::endl ;
 989 }
 990
 991 RefCountPtr< const Lang::Exception >
 992 Exceptions::UserTypeMismatch::clone( const Kernel::ContRef & cont ) const
 993 {
 994         std::ostringstream os;
 995         display( os );
 996         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
 997                                                                                                                                                                                                                                                                                 kind_,
 998                                                                                                                                                                                                                                                                                 source_,
 999                                                                                                                                                                                                                                                                                 details_,
1000                                                                                                                                                                                                                                                                                 strrefdup( os ),
1001                                                                                                                                                                                                                                                                                 cont,
1002                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1003 }
1004
1005
1006 Exceptions::InternalError::InternalError( const Ast::SourceLocation & loc, RefCountPtr< const char > msg, bool justAWarning )
1007         : Exceptions::RuntimeError( loc ), msg_( msg.getPtr( ) ), msgMem_( msg ), justAWarning_( justAWarning )
1008 { }
1009
1010 Exceptions::InternalError::InternalError( const Ast::SourceLocation & loc, const char * msg, bool justAWarning )
1011         : Exceptions::RuntimeError( loc ), msg_( msg ), msgMem_( NullPtr< const char >( ) ), justAWarning_( justAWarning )
1012 { }
1013
1014 Exceptions::InternalError::InternalError( RefCountPtr< const char > msg, bool justAWarning )
1015         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg.getPtr( ) ), msgMem_( msg ), justAWarning_( justAWarning )
1016 { }
1017
1018 Exceptions::InternalError::InternalError( const char * msg, bool justAWarning )
1019         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg ), msgMem_( NullPtr< const char >( ) ), justAWarning_( justAWarning )
1020 { }
1021
1022 Exceptions::InternalError::InternalError( const std::ostringstream & msg, bool justAWarning )
1023         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), msg_( strdup( msg.str( ).c_str( ) ) ), msgMem_( msg_ ), justAWarning_( justAWarning )
1024 { }
1025
1026 Exceptions::InternalError::~InternalError( )
1027 { }
1028
1029 void
1030 Exceptions::InternalError::display( ostream & os ) const
1031 {
1032         os << "Internal " << ( justAWarning_ ? "warning" : "error" ) << ": " << msg_ << std::endl ;
1033 }
1034
1035
1036 Exceptions::ExternalError::ExternalError( RefCountPtr< const char > msg, bool justAWarning )
1037         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg.getPtr( ) ), msgMem_( msg ), justAWarning_( justAWarning )
1038 { }
1039
1040 Exceptions::ExternalError::ExternalError( const char * msg, bool justAWarning )
1041         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), msg_( msg ), msgMem_( NullPtr< const char >( ) ), justAWarning_( justAWarning )
1042 { }
1043
1044 Exceptions::ExternalError::~ExternalError( )
1045 { }
1046
1047 void
1048 Exceptions::ExternalError::display( ostream & os ) const
1049 {
1050         os << "External " << ( justAWarning_ ? "warning" : "error" ) << ": " << msg_ << std::endl ;
1051 }
1052
1053 RefCountPtr< const Lang::Exception >
1054 Exceptions::ExternalError::clone( const Kernel::ContRef & cont ) const
1055 {
1056         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "external" ) );
1057         std::ostringstream os;
1058         display( os );
1059         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1060                                                                                                                                                                                                                                                                                 kind,
1061                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(external error)", true ) ),
1062                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
1063                                                                                                                                                                                                                                                                                 strrefdup( os ),
1064                                                                                                                                                                                                                                                                                 cont,
1065                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1066 }
1067
1068 Exceptions::ExternalError *
1069 Exceptions::ExternalError::cloneTyped( ) const
1070 {
1071         return new Exceptions::ExternalError( msgMem_ );
1072 }
1073
1074 Exceptions::UserArityMismatch::UserArityMismatch( const Ast::SourceLocation _formalsLoc, size_t _functionArity, size_t _callArity, Type type )
1075         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), formalsLoc( _formalsLoc ), functionArity( _functionArity ), callArity( _callArity ), type_( type )
1076 { }
1077
1078 Exceptions::UserArityMismatch::~UserArityMismatch( )
1079 { }
1080
1081 void
1082 Exceptions::UserArityMismatch::display( std::ostream & os ) const
1083 {
1084         os << "Function with formals at " << formalsLoc << " expects " << functionArity ;
1085         switch( type_ )
1086                 {
1087                 case VARIABLE:
1088                         os << " value arguments" ;
1089                         break;
1090                 case STATE:
1091                         os << " state arguments" ;
1092                         break;
1093                 default:
1094                         os << " ?ERROR?" ;
1095                 }
1096         os << ", not " << callArity << std::endl ;
1097 }
1098
1099 Exceptions::SinkRequired::SinkRequired( const Ast::SourceLocation formalsLoc, size_t formalsArity, size_t callArity )
1100         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), formalsLoc_( formalsLoc ), formalsArity_( formalsArity ), callArity_( callArity )
1101 { }
1102
1103 Exceptions::SinkRequired::~SinkRequired( )
1104 { }
1105
1106 void
1107 Exceptions::SinkRequired::display( std::ostream & os ) const
1108 {
1109         os << "Formals at " << formalsLoc_ << " contains no sink, so passing " << callArity_ << " ordered arguments is " << callArity_ - formalsArity_ << " too many." << std::endl ;
1110 }
1111
1112
1113 Exceptions::NamedFormalMismatch::NamedFormalMismatch( const Ast::SourceLocation _formalsLoc, RefCountPtr< const char > _name, Exceptions::NamedFormalMismatch::Type type )
1114         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), formalsLoc( _formalsLoc ), name( _name ), type_( type )
1115 { }
1116
1117 Exceptions::NamedFormalMismatch::~NamedFormalMismatch( )
1118 { }
1119
1120 void
1121 Exceptions::NamedFormalMismatch::display( std::ostream & os ) const
1122 {
1123         os << "Function with formals at " << formalsLoc << " has no named ";
1124         switch( type_ )
1125                 {
1126                 case VARIABLE:
1127                         os << "variable" ;
1128                         break;
1129                 case STATE:
1130                         os << "state" ;
1131                         break;
1132                 default:
1133                         os << "<?ERROR?" ;
1134                 }
1135         os << " called " << name << "." << std::endl ;
1136 }
1137
1138
1139 Exceptions::NamedFormalAlreadySpecified::NamedFormalAlreadySpecified( const Ast::SourceLocation _formalsLoc, RefCountPtr< const char > _name, size_t _pos, Exceptions::NamedFormalAlreadySpecified::Type type )
1140         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), formalsLoc( _formalsLoc ), name( _name ), pos( _pos ), type_( type     )
1141 { }
1142
1143 Exceptions::NamedFormalAlreadySpecified::~NamedFormalAlreadySpecified( )
1144 { }
1145
1146 void
1147 Exceptions::NamedFormalAlreadySpecified::display( std::ostream & os ) const
1148 {
1149         os << "The formal " ;
1150         switch( type_ )
1151                 {
1152                 case VARIABLE:
1153                         os << "variable" ;
1154                         break;
1155                 case STATE:
1156                         os << "state" ;
1157                         break;
1158                 default:
1159                         os << "<?ERROR?" ;
1160                 }
1161         os << " named " << name << ", defined at " << formalsLoc << " is already defined by order, at position " << pos << "." << std::endl ;
1162 }
1163
1164 Exceptions::MissingArguments::MissingArguments( const Ast::SourceLocation formalsLoc, std::map< size_t, RefCountPtr< const char > > * missingVariables, std::map< size_t, RefCountPtr< const char > > * missingStates )
1165         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), formalsLoc_( formalsLoc ), missingVariables_( missingVariables ), missingStates_( missingStates )
1166 { }
1167
1168 Exceptions::MissingArguments::~MissingArguments( )
1169 { }
1170
1171 void
1172 Exceptions::MissingArguments::display( std::ostream & os ) const
1173 {
1174         os << "Among the formals at " << formalsLoc_ ;
1175         if( missingVariables_ != NullPtr< typeof *missingVariables_ >( ) )
1176                 {
1177                         os << ", the following variables are missing:" ;
1178                         typedef typeof *missingVariables_ MapType;
1179                         for( MapType::const_iterator i = missingVariables_->begin( ); i != missingVariables_->end( ); ++i )
1180                                 {
1181                                         if( i != missingVariables_->begin( ) )
1182                                                 {
1183                                                         os << "," ;
1184                                                 }
1185                                         os << " (" << i->first << ")" << i->second.getPtr( ) ;
1186                                 }
1187                 }
1188         if( missingStates_ != NullPtr< typeof *missingStates_ >( ) )
1189                 {
1190                         os << ", " ;
1191                         if( missingVariables_ != NullPtr< typeof *missingVariables_ >( ) )
1192                                 {
1193                                         os << "and " ;
1194                                 }
1195                         os << "the following states are missing:" ;
1196                         typedef typeof *missingStates_ MapType;
1197                         for( MapType::const_iterator i = missingStates_->begin( ); i != missingStates_->end( ); ++i )
1198                                 {
1199                                         if( i != missingStates_->begin( ) )
1200                                                 {
1201                                                         os << "," ;
1202                                                 }
1203                                         os << " (" << i->first << ")" << i->second.getPtr( ) ;
1204                                 }
1205                 }
1206         os << "." << std::endl ;
1207 }
1208
1209
1210 Exceptions::CoreArityMismatch::CoreArityMismatch( const char * _title, size_t _functionArity, size_t _callArity )
1211         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title ), titleMem( NullPtr< const char >( ) ), functionArityLow( _functionArity ), functionArityHigh( _functionArity ), callArity( _callArity )
1212 { }
1213
1214 Exceptions::CoreArityMismatch::CoreArityMismatch( const char * _title, size_t _functionArityLow, size_t _functionArityHigh, size_t _callArity )
1215         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title ), titleMem( NullPtr< const char >( ) ), functionArityLow( _functionArityLow ), functionArityHigh( _functionArityHigh ), callArity( _callArity )
1216 { }
1217
1218 Exceptions::CoreArityMismatch::CoreArityMismatch( const RefCountPtr< const char > & _title, size_t _functionArity, size_t _callArity )
1219         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title.getPtr( ) ), titleMem( _title ), functionArityLow( _functionArity ), functionArityHigh( _functionArity ), callArity( _callArity )
1220 { }
1221
1222 Exceptions::CoreArityMismatch::CoreArityMismatch( const RefCountPtr< const char > & _title, size_t _functionArityLow, size_t _functionArityHigh, size_t _callArity )
1223         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title.getPtr( ) ), titleMem( _title ), functionArityLow( _functionArityLow ), functionArityHigh( _functionArityHigh ), callArity( _callArity )
1224 { }
1225
1226 Exceptions::CoreArityMismatch::~CoreArityMismatch( )
1227 { }
1228
1229 void
1230 Exceptions::CoreArityMismatch::display( std::ostream & os ) const
1231 {
1232         if( functionArityLow == functionArityHigh )
1233                 {
1234                         os << "Core function " << title << " expects " << functionArityLow << " arguments, not " << callArity << std::endl ;
1235                 }
1236         else
1237                 {
1238                         os << "Core function " << title << " expects [" << functionArityLow << ", " << functionArityHigh << "] arguments, not " << callArity << std::endl ;
1239                 }
1240 }
1241
1242
1243 Exceptions::CoreNoNamedFormals::CoreNoNamedFormals( const char * _title )
1244         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title ), titleMem( NullPtr< const char >( ) )
1245 { }
1246
1247 Exceptions::CoreNoNamedFormals::CoreNoNamedFormals( const RefCountPtr< const char > & _title )
1248         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), title( _title.getPtr( ) ), titleMem( _title )
1249 { }
1250
1251 Exceptions::CoreNoNamedFormals::~CoreNoNamedFormals( )
1252 { }
1253
1254 void
1255 Exceptions::CoreNoNamedFormals::display( std::ostream & os ) const
1256 {
1257         os << "Core function " << title << " does not accept named arguments." << std::endl ;
1258 }
1259
1260
1261 Exceptions::CoreTypeMismatch::CoreTypeMismatch( const Ast::SourceLocation & callLoc,
1262                                                                                                                                                                                  const char * title,
1263                                                                                                                                                                                  const Ast::SourceLocation & argLoc,
1264                                                                                                                                                                                  RefCountPtr< const char > valueType,
1265                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1266         : Exceptions::RuntimeError( callLoc ),
1267                 title_( title ),
1268                 titleMem_( NullPtr< const char >( ) ),
1269                 argLoc_( argLoc ),
1270                 valueType_( valueType ),
1271                 expectedType_( expectedType )
1272 { }
1273
1274 Exceptions::CoreTypeMismatch::CoreTypeMismatch( const Ast::SourceLocation & callLoc,
1275                                                                                                                                                                                  RefCountPtr< const char > title,
1276                                                                                                                                                                                  const Ast::SourceLocation & argLoc,
1277                                                                                                                                                                                  RefCountPtr< const char > valueType,
1278                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1279         : Exceptions::RuntimeError( callLoc ),
1280                 title_( title.getPtr( ) ),
1281                 titleMem_( title ),
1282                 argLoc_( argLoc ),
1283                 valueType_( valueType ),
1284                 expectedType_( expectedType )
1285 { }
1286
1287 Exceptions::CoreTypeMismatch::CoreTypeMismatch( const Ast::SourceLocation & callLoc,
1288                                                                                                                                                                                                 const char * title,
1289                                                                                                                                                                                                 Kernel::Arguments & args,
1290                                                                                                                                                                                                 size_t argNo,
1291                                                                                                                                                                                                 RefCountPtr< const char > expectedType )
1292         : Exceptions::RuntimeError( callLoc ),
1293                 title_( title ),
1294                 titleMem_( NullPtr< const char >( ) ),
1295                 argLoc_( args.getLoc( argNo ) ),
1296                 valueType_( args.getValue( argNo )->getTypeName( ) ),
1297                 expectedType_( expectedType )
1298 { }
1299
1300 Exceptions::CoreTypeMismatch::CoreTypeMismatch( const Ast::SourceLocation & callLoc,
1301                                                                                                                                                                                  RefCountPtr< const char > title,
1302                                                                                                                                                                                  Kernel::Arguments & args,
1303                                                                                                                                                                                  size_t argNo,
1304                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1305         : Exceptions::RuntimeError( callLoc ),
1306                 title_( title.getPtr( ) ),
1307                 titleMem_( title ),
1308                 argLoc_( args.getLoc( argNo ) ),
1309                 valueType_( args.getValue( argNo )->getTypeName( ) ),
1310                 expectedType_( expectedType )
1311 { }
1312
1313 Exceptions::CoreTypeMismatch::~CoreTypeMismatch( )
1314 { }
1315
1316 void
1317 Exceptions::CoreTypeMismatch::display( std::ostream & os ) const
1318 {
1319         os << "Core function " << title_ << ", argument ";
1320         //      if( argName_ != 0 )
1321         //              {
1322         //                      os << "\"" << argName_ << "\" " ;
1323         //              }
1324         os << "at " << argLoc_ << ": expected a " << expectedType_ << ", got a " << valueType_ << "." << std::endl ;
1325 }
1326
1327
1328 Exceptions::CoreStateTypeMismatch::CoreStateTypeMismatch( const Ast::SourceLocation & callLoc,
1329                                                                                                                                                                                  const char * title,
1330                                                                                                                                                                                  const Ast::SourceLocation & argLoc,
1331                                                                                                                                                                                  RefCountPtr< const char > valueType,
1332                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1333         : Exceptions::RuntimeError( callLoc ),
1334                 title_( title ),
1335                 titleMem_( NullPtr< const char >( ) ),
1336                 argLoc_( argLoc ),
1337                 valueType_( valueType ),
1338                 expectedType_( expectedType )
1339 { }
1340
1341 Exceptions::CoreStateTypeMismatch::CoreStateTypeMismatch( const Ast::SourceLocation & callLoc,
1342                                                                                                                                                                                  RefCountPtr< const char > title,
1343                                                                                                                                                                                  const Ast::SourceLocation & argLoc,
1344                                                                                                                                                                                  RefCountPtr< const char > valueType,
1345                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1346         : Exceptions::RuntimeError( callLoc ),
1347                 title_( title.getPtr( ) ),
1348                 titleMem_( title ),
1349                 argLoc_( argLoc ),
1350                 valueType_( valueType ),
1351                 expectedType_( expectedType )
1352 { }
1353
1354 Exceptions::CoreStateTypeMismatch::CoreStateTypeMismatch( const Ast::SourceLocation & callLoc,
1355                                                                                                                                                                                                 const char * title,
1356                                                                                                                                                                                                 Kernel::Arguments & args,
1357                                                                                                                                                                                                 size_t argNo,
1358                                                                                                                                                                                                 RefCountPtr< const char > expectedType )
1359         : Exceptions::RuntimeError( callLoc ),
1360                 title_( title ),
1361                 titleMem_( NullPtr< const char >( ) ),
1362                 argLoc_( args.getStateLoc( argNo ) ),
1363                 valueType_( args.getState( argNo )->getTypeName( ) ),
1364                 expectedType_( expectedType )
1365 { }
1366
1367 Exceptions::CoreStateTypeMismatch::CoreStateTypeMismatch( const Ast::SourceLocation & callLoc,
1368                                                                                                                                                                                  RefCountPtr< const char > title,
1369                                                                                                                                                                                  Kernel::Arguments & args,
1370                                                                                                                                                                                  size_t argNo,
1371                                                                                                                                                                                  RefCountPtr< const char > expectedType )
1372         : Exceptions::RuntimeError( callLoc ),
1373                 title_( title.getPtr( ) ),
1374                 titleMem_( title ),
1375                 argLoc_( args.getStateLoc( argNo ) ),
1376                 valueType_( args.getState( argNo )->getTypeName( ) ),
1377                 expectedType_( expectedType )
1378 { }
1379
1380 Exceptions::CoreStateTypeMismatch::~CoreStateTypeMismatch( )
1381 { }
1382
1383 void
1384 Exceptions::CoreStateTypeMismatch::display( std::ostream & os ) const
1385 {
1386         os << "Core function " << title_ << ", state ";
1387         //      if( argName_ != 0 )
1388         //              {
1389         //                      os << "\"" << argName_ << "\" " ;
1390         //              }
1391         os << "at " << argLoc_ << ": expected a " << expectedType_ << ", got a " << valueType_ << "." << std::endl ;
1392 }
1393
1394
1395 Exceptions::CoreDynamicTypeMismatch::CoreDynamicTypeMismatch( const Ast::SourceLocation & callLoc,
1396                                                                                                                                                                                                                                                         const char * title,
1397                                                                                                                                                                                                                                                         const char * id,
1398                                                                                                                                                                                                                                                         RefCountPtr< const char > valueType,
1399                                                                                                                                                                                                                                                         RefCountPtr< const char > expectedType )
1400         : Exceptions::RuntimeError( callLoc ),
1401                 title_( title ),
1402                 titleMem_( NullPtr< const char >( ) ),
1403                 id_( id ),
1404                 idMem_( NullPtr< const char >( ) ),
1405                 valueType_( valueType ),
1406                 expectedType_( expectedType )
1407 { }
1408
1409 Exceptions::CoreDynamicTypeMismatch::~CoreDynamicTypeMismatch( )
1410 { }
1411
1412 void
1413 Exceptions::CoreDynamicTypeMismatch::display( std::ostream & os ) const
1414 {
1415         os << "Core function " << title_ << " encountered a type mismatch in the dynamic variable @" << id_
1416                  << ": expected a " << expectedType_ << ", got a " << valueType_ << "." << std::endl ;
1417 }
1418
1419 Exceptions::ContinuationTypeMismatch::ContinuationTypeMismatch( const Kernel::Continuation * locationCont,
1420                                                                                                                                                                                                                                                                 RefCountPtr< const char > valueType,
1421                                                                                                                                                                                                                                                                 RefCountPtr< const char > expectedType )
1422         : Exceptions::RuntimeError( locationCont->traceLoc( ) ),
1423                 valueType_( valueType ),
1424                 expectedType_( expectedType )
1425 { }
1426
1427 Exceptions::ContinuationTypeMismatch::~ContinuationTypeMismatch( )
1428 { }
1429
1430 void
1431 Exceptions::ContinuationTypeMismatch::display( std::ostream & os ) const
1432 {
1433         os << "The continuation expected a " << expectedType_ << ", got a " << valueType_ << "." << std::endl ;
1434 }
1435
1436
1437 Exceptions::CoreOutOfRange::CoreOutOfRange( const char * title, Kernel::Arguments & args, size_t argNo, RefCountPtr< const char > msg )
1438         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), title_( title ), argNo_( argNo ), argLoc_( args.getLoc( argNo ) ), msg_( msg.getPtr( ) ), msgMem_( msg )
1439 { }
1440
1441 Exceptions::CoreOutOfRange::CoreOutOfRange( const char * title, Kernel::Arguments & args, size_t argNo, const char * msg )
1442         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), title_( title ), argNo_( argNo ), argLoc_( args.getLoc( argNo ) ), msg_( msg ), msgMem_( NullPtr< const char >( ) )
1443 { }
1444
1445 Exceptions::CoreOutOfRange::~CoreOutOfRange( )
1446 { }
1447
1448 void
1449 Exceptions::CoreOutOfRange::display( std::ostream & os ) const
1450 {
1451         os << "Core function " << title_ << ": " ;
1452         os << "Argument at " << argLoc_ << " is out of range; " << msg_ << std::endl ;
1453 }
1454
1455 RefCountPtr< const Lang::Exception >
1456 Exceptions::CoreOutOfRange::clone( const Kernel::ContRef & cont ) const
1457 {
1458         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "out_of_range" ) );
1459         std::ostringstream os;
1460         display( os );
1461         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1462                                                                                                                                                                                                                                                                                 kind,
1463                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( title_, true ) ),
1464                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::Integer >( new Lang::Integer( argNo_ ) ),
1465                                                                                                                                                                                                                                                                                 strrefdup( os ),
1466                                                                                                                                                                                                                                                                                 cont,
1467                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1468 }
1469
1470 Exceptions::CoreRequirement::CoreRequirement( RefCountPtr< const char > msg, const char * title, const Ast::SourceLocation & callLoc )
1471         : Exceptions::CatchableError( callLoc ), title_( title ), msg_( msg.getPtr( ) ), msgMem_( msg )
1472 { }
1473
1474 Exceptions::CoreRequirement::CoreRequirement( const char * msg, const char * title, const Ast::SourceLocation & callLoc )
1475         : Exceptions::CatchableError( callLoc ), title_( title ), msg_( msg ), msgMem_( NullPtr< const char >( ) )
1476 { }
1477
1478 Exceptions::CoreRequirement::~CoreRequirement( )
1479 { }
1480
1481 void
1482 Exceptions::CoreRequirement::display( std::ostream & os ) const
1483 {
1484         os << "Core function " << title_ << ": " << msg_ << std::endl ;
1485 }
1486
1487 RefCountPtr< const Lang::Exception >
1488 Exceptions::CoreRequirement::clone( const Kernel::ContRef & cont ) const
1489 {
1490         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
1491         std::ostringstream os;
1492         display( os );
1493         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1494                                                                                                                                                                                                                                                                                 kind,
1495                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( title_, true ) ),
1496                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
1497                                                                                                                                                                                                                                                                                 strrefdup( os ),
1498                                                                                                                                                                                                                                                                                 cont,
1499                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1500 }
1501
1502
1503 Exceptions::BuildRequirement::BuildRequirement( const char * dependency, const char * title, const Ast::SourceLocation & callLoc )
1504         : Exceptions::CatchableError( callLoc ), title_( title ), dependency_( dependency )
1505 { }
1506
1507 Exceptions::BuildRequirement::~BuildRequirement( )
1508 { }
1509
1510 void
1511 Exceptions::BuildRequirement::display( std::ostream & os ) const
1512 {
1513         os << "Core function stub " << title_ << ": Shapes was built without " << dependency_ << ", so this function cannot be called." << std::endl ;
1514 }
1515
1516 RefCountPtr< const Lang::Exception >
1517 Exceptions::BuildRequirement::clone( const Kernel::ContRef & cont ) const
1518 {
1519         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
1520         std::ostringstream os;
1521         display( os );
1522         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1523                                                                                                                                                                                                                                                                                 kind,
1524                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( title_, true ) ),
1525                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
1526                                                                                                                                                                                                                                                                                 strrefdup( os ),
1527                                                                                                                                                                                                                                                                                 cont,
1528                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1529 }
1530
1531
1532 Exceptions::TeXLabelError::TeXLabelError( bool quoted, const char * region, RefCountPtr< const char > summary, RefCountPtr< const char > details, const Ast::SourceLocation & loc )
1533         : Exceptions::RuntimeError( loc ), strLoc_( loc ), quoted_( quoted ), region_( region ), summary_( summary ), details_( details )
1534 { }
1535
1536 Exceptions::TeXLabelError::~TeXLabelError( )
1537 { }
1538
1539 void
1540 Exceptions::TeXLabelError::display( ostream & os ) const
1541 {
1542         if( quoted_ )
1543                 {
1544                         os << "TeX error in " << region_ ;
1545                 }
1546         else
1547                 {
1548                         os << "Error in TeX " << region_ ;
1549                 }
1550         if( ! strLoc_.isUnknown( ) )
1551                 {
1552                         os << " at " << strLoc_ ;
1553                 }
1554         os << ": " ;
1555         if( quoted_ )
1556                 {
1557                         os << "\"" ;
1558                 }
1559         os << summary_ ;
1560         if( quoted_ )
1561                 {
1562                         os << "\"" ;
1563                 }
1564         os << std::endl ;
1565         if( details_ != NullPtr< const char >( ) )
1566                 {
1567                         Exceptions::prefixEachLine( additionalLinesPrefix, details_, os );
1568                 }
1569 }
1570
1571
1572 Exceptions::StaticTeXLabelError::StaticTeXLabelError( bool quoted, const char * region, RefCountPtr< const char > summary, RefCountPtr< const char > details, const Ast::SourceLocation & loc )
1573         : Exceptions::StaticInconsistency( loc ), quoted_( quoted ), region_( region ), summary_( summary ), details_( details )
1574 { }
1575
1576 Exceptions::StaticTeXLabelError::~StaticTeXLabelError( )
1577 { }
1578
1579 void
1580 Exceptions::StaticTeXLabelError::display( ostream & os ) const
1581 {
1582         if( quoted_ )
1583                 {
1584                         os << "TeX error in " << region_ ;
1585                 }
1586         else
1587                 {
1588                         os << "Error in TeX " << region_ ;
1589                 }
1590         os << ": " ;
1591         if( quoted_ )
1592                 {
1593                         os << "\"" ;
1594                 }
1595         os << summary_ ;
1596         if( quoted_ )
1597                 {
1598                         os << "\"" ;
1599                 }
1600         os << std::endl ;
1601         if( details_ != NullPtr< const char >( ) )
1602                 {
1603                         Exceptions::prefixEachLine( additionalLinesPrefix, details_, os );
1604                 }
1605 }
1606
1607
1608 Exceptions::MultipleDynamicBind::MultipleDynamicBind( const char * _id, const Ast::SourceLocation & _loc, const Ast::SourceLocation & _prevLoc )
1609         : Exceptions::RuntimeError( _loc ), id( _id ), prevLoc( _prevLoc )
1610 { }
1611
1612 Exceptions::MultipleDynamicBind::~MultipleDynamicBind( )
1613 { }
1614
1615 void
1616 Exceptions::MultipleDynamicBind::display( std::ostream & os ) const
1617 {
1618         os << "This dynamic binding of " << id << " is merged with the conflicting binding at " << prevLoc << "." << std::endl ;
1619 }
1620
1621
1622 Exceptions::UndefinedEscapeContinuation::UndefinedEscapeContinuation( const char * _id, const Ast::SourceLocation & _loc )
1623         : Exceptions::RuntimeError( _loc ), id( _id )
1624 { }
1625
1626 Exceptions::UndefinedEscapeContinuation::~UndefinedEscapeContinuation( )
1627 { }
1628
1629 void
1630 Exceptions::UndefinedEscapeContinuation::display( std::ostream & os ) const
1631 {
1632         os << "The escape continuation " << id << " was not defined in the dynamic context." << std::endl ;
1633 }
1634
1635
1636 Exceptions::DeadStateAccess::DeadStateAccess( )
1637         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION )
1638 { }
1639
1640 Exceptions::DeadStateAccess::~DeadStateAccess( )
1641 { }
1642
1643 void
1644 Exceptions::DeadStateAccess::display( std::ostream & os ) const
1645 {
1646         os << "Accessing dead state." << std::endl ;
1647 }
1648
1649
1650 Exceptions::UnFreezable::UnFreezable( )
1651         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION )
1652 { }
1653
1654 Exceptions::UnFreezable::~UnFreezable( )
1655 { }
1656
1657 void
1658 Exceptions::UnFreezable::display( std::ostream & os ) const
1659 {
1660         os << "The state cannot be frozen." << std::endl ;
1661 }
1662
1663
1664 Exceptions::UnPeekable::UnPeekable( )
1665         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION )
1666 { }
1667
1668 Exceptions::UnPeekable::~UnPeekable( )
1669 { }
1670
1671 void
1672 Exceptions::UnPeekable::display( std::ostream & os ) const
1673 {
1674         os << "The state cannot be peeked.      Consider freezing it." << std::endl ;
1675 }
1676
1677
1678 Exceptions::UninitializedAccess::UninitializedAccess( )
1679         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION )
1680 { }
1681
1682 Exceptions::UninitializedAccess::~UninitializedAccess( )
1683 { }
1684
1685 void
1686 Exceptions::UninitializedAccess::display( std::ostream & os ) const
1687 {
1688         os << "The accessed variable or state has not been initialized yet." << std::endl ;
1689 }
1690
1691
1692 Exceptions::DtMinError::DtMinError( double _dt )
1693         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), dt( _dt )
1694 { }
1695
1696 Exceptions::DtMinError::~DtMinError( )
1697 { }
1698
1699 void
1700 Exceptions::DtMinError::display( std::ostream & os ) const
1701 {
1702         os << "Path segment too long in relation to arcdelta: dt = " << dt << " < " << Computation::the_dtMin << ".     Either increase arcdelta, or inhibit this error." << std::endl ;
1703 }
1704
1705 RefCountPtr< const Lang::Exception >
1706 Exceptions::DtMinError::clone( const Kernel::ContRef & cont ) const
1707 {
1708         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "dtmin" ) );
1709         std::ostringstream os;
1710         display( os );
1711         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1712                                                                                                                                                                                                                                                                                 kind,
1713                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core path computation)", true ) ),
1714                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::Float >( new Lang::Float( dt / Computation::the_dtMin ) ),
1715                                                                                                                                                                                                                                                                                 strrefdup( os ),
1716                                                                                                                                                                                                                                                                                 cont,
1717                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1718 }
1719
1720
1721 Exceptions::AffineTransformKillsPlane::AffineTransformKillsPlane( double sigma2 )
1722         : Exceptions::CatchableError( Ast::THE_UNKNOWN_LOCATION ), sigma2_( sigma2 )
1723 { }
1724
1725 Exceptions::AffineTransformKillsPlane::~AffineTransformKillsPlane( )
1726 { }
1727
1728 void
1729 Exceptions::AffineTransformKillsPlane::display( std::ostream & os ) const
1730 {
1731         os << "When transforming a plane normal, it was found that the affine transform is too singular, with a second largest singular value of " << sigma2_ << "." << std::endl ;
1732 }
1733
1734 RefCountPtr< const Lang::Exception >
1735 Exceptions::AffineTransformKillsPlane::clone( const Kernel::ContRef & cont ) const
1736 {
1737         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "numeric" ) );
1738         std::ostringstream os;
1739         display( os );
1740         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1741                                                                                                                                                                                                                                                                                 kind,
1742                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core float triple computation)", true ) ),
1743                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
1744                                                                                                                                                                                                                                                                                 strrefdup( os ),
1745                                                                                                                                                                                                                                                                                 cont,
1746                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1747 }
1748
1749 Exceptions::MissingFontMetrics::MissingFontMetrics( RefCountPtr< const char > fontname, const std::list< std::string > * searchPath )
1750         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), fontname_( fontname ), searchPath_( searchPath )
1751 { }
1752
1753 Exceptions::MissingFontMetrics::~MissingFontMetrics( )
1754 { }
1755
1756 void
1757 Exceptions::MissingFontMetrics::display( std::ostream & os ) const
1758 {
1759         os << "The font metrics for " << fontname_ << ", named " << fontname_ << ".afm, could not be found in {" ;
1760         typedef typeof *searchPath_ ListType;
1761         for( ListType::const_iterator i = searchPath_->begin( ); i != searchPath_->end( ); ++i )
1762                 {
1763                         os << " " << *i ;
1764                 }
1765         os << " }." << std::endl ;
1766 }
1767
1768
1769 Exceptions::FontMetricsError::FontMetricsError( const RefCountPtr< const char > & fontname, const RefCountPtr< const char > & message )
1770         : Exceptions::RuntimeError( Ast::THE_UNKNOWN_LOCATION ), fontname_( fontname ), message_( message )
1771 { }
1772
1773 Exceptions::FontMetricsError::~FontMetricsError( )
1774 { }
1775
1776 void
1777 Exceptions::FontMetricsError::display( std::ostream & os ) const
1778 {
1779         os << "There was a problem with the font metrics for " << fontname_ << ": " << message_ << std::endl ;
1780 }
1781
1782
1783 Exceptions::InsertingEmptyPage::InsertingEmptyPage( const Ast::SourceLocation & loc )
1784         : Exceptions::CatchableError( loc )
1785 { }
1786
1787 Exceptions::InsertingEmptyPage::~InsertingEmptyPage( )
1788 { }
1789
1790 void
1791 Exceptions::InsertingEmptyPage::display( std::ostream & os ) const
1792 {
1793         os << "Attempt to place empty page in catalog." << std::endl ;
1794 }
1795
1796 RefCountPtr< const Lang::Exception >
1797 Exceptions::InsertingEmptyPage::clone( const Kernel::ContRef & cont ) const
1798 {
1799         static RefCountPtr< const Lang::Symbol > kind( new Lang::Symbol( "misc" ) );
1800         std::ostringstream os;
1801         display( os );
1802         return RefCountPtr< const Lang::Exception >( new Lang::Exception( this->getLoc( ),
1803                                                                                                                                                                                                                                                                                 kind,
1804                                                                                                                                                                                                                                                                                 RefCountPtr< const Lang::String >( new Lang::String( "(core exception)", true ) ),
1805                                                                                                                                                                                                                                                                                 Lang::THE_VOID,
1806                                                                                                                                                                                                                                                                                 strrefdup( os ),
1807                                                                                                                                                                                                                                                                                 cont,
1808                                                                                                                                                                                                                                                                                 this->exitCode( ) ) );
1809 }
1810
1811
1812 Exceptions::UndefinedCrossRef::UndefinedCrossRef( const Ast::SourceLocation & _loc, RefCountPtr< const char > ref )
1813         : Exceptions::PostCondition( _loc ), ref_( ref )
1814 { }
1815
1816 Exceptions::UndefinedCrossRef::~UndefinedCrossRef( )
1817 { }
1818
1819 void
1820 Exceptions::UndefinedCrossRef::display( std::ostream & os ) const
1821 {
1822         os << "The cross reference \"" << ref_ << "\" is not defined." << std::endl ;
1823 }
1824
1825
1826 void
1827 Exceptions::prefixEachLine( const std::string & prefix, std::istream & src, std::ostream & dst )
1828 {
1829         std::string line;
1830         for( std::getline( src, line ); ! src.eof( ); std::getline( src, line ) )
1831                 {
1832                         dst << prefix << line << std::endl ;
1833                 }
1834 }
1835
1836 void
1837 Exceptions::prefixEachLine( const std::string & prefix, const RefCountPtr< const char > & src, std::ostream & dst )
1838 {
1839         std::istringstream is( src.getPtr( ) );
1840         Exceptions::prefixEachLine( prefix, is, dst );
1841 }