source/shapesexceptions.cc

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