source/elementarytypes.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 Henrik Tidefelt
  17  */
  18
  19 #include <cmath>
  20
  21 #include "shapestypes.h"
  22 #include "shapesexceptions.h"
  23 #include "astexpr.h"
  24 #include "consts.h"
  25 #include "angleselect.h"
  26 #include "astvar.h"
  27 #include "astclass.h"
  28 #include "elementarycoords.h"
  29 #include "globals.h"
  30
  31 #include <ctype.h>
  32 #include <stack>
  33
  34 using namespace Shapes;
  35 using namespace std;
  36
  37
  38 Lang::Void::Void( )
  39 { }
  40
  41 RefCountPtr< const Lang::Class > Lang::Void::TypeID( new Lang::SystemFinalClass( strrefdup( "Void" ) ) );
  42 TYPEINFOIMPL( Void );
  43
  44 void
  45 Lang::Void::show( std::ostream & os ) const
  46 {
  47 }
  48
  49
  50 Lang::Symbol::NameTableType Lang::Symbol::nameTable;
  51 Lang::Symbol::ReverseTableType Lang::Symbol::reverseTable;
  52 int Lang::Symbol::nextUnique = -1;
  53
  54 /* The following global variables used to be in globals.cc, but now they are here to ensure they get initialized after the static variables in Lang::Symbol.
  55  */
  56 RefCountPtr< const Lang::Symbol > Kernel::THE_NAVIGATION_SYMBOL( ".navigation" ); /* Note that the leading dot puts this symbol aside all user-symbols. */
  57 RefCountPtr< const Lang::Symbol > Kernel::THE_ANNOTATION_SYMBOL( ".annotation" ); /* Note that the leading dot puts this symbol aside all user-symbols. */
  58
  59 Lang::Symbol::Symbol( )
  60 {
  61         key_ = nextUnique;
  62         --nextUnique;
  63 }
  64
  65 DISPATCHIMPL( Symbol );
  66
  67 Lang::Symbol::Symbol( int key )
  68 {
  69         if( key != 0 )
  70                 {
  71                         throw Exceptions::InternalError( "Only the key 0 may be used when creating symbols with a given key." );
  72                 }
  73         key_ = 0;
  74 }
  75
  76 Lang::Symbol::Symbol( const char * name )
  77 {
  78         NameTableType::const_iterator i = nameTable.find( name );
  79         if( i != nameTable.end( ) )
  80                 {
  81                         key_ = i->second;
  82                 }
  83         else
  84                 {
  85                         const char * nameCopy = strdup( name );
  86                         key_ = nameTable.size( ) + 1;
  87                         nameTable[ nameCopy ] = key_;
  88                         reverseTable.insert( ReverseTableType::value_type( key_, RefCountPtr< const char >( nameCopy ) ) );
  89                 }
  90 }
  91
  92 bool
  93 Lang::Symbol::operator == ( const Symbol & other ) const
  94 {
  95         return key_ == other.key_;
  96 }
  97
  98 bool
  99 Lang::Symbol::operator != ( const Symbol & other ) const
 100 {
 101         return key_ != other.key_;
 102 }
 103
 104 bool
 105 Lang::Symbol::operator < ( const Symbol & other ) const
 106 {
 107         return key_ < other.key_;
 108 }
 109
 110 bool
 111 Lang::Symbol::operator > ( const Symbol & other ) const
 112 {
 113         return key_ > other.key_;
 114 }
 115
 116 bool
 117 Lang::Symbol::operator <= ( const Symbol & other ) const
 118 {
 119         return key_ <= other.key_;
 120 }
 121
 122 bool
 123 Lang::Symbol::operator >= ( const Symbol & other ) const
 124 {
 125         return key_ >= other.key_;
 126 }
 127
 128 bool
 129 Lang::Symbol::isUnique( ) const
 130 {
 131         return key_ < 0;
 132 }
 133
 134 RefCountPtr< const char >
 135 Lang::Symbol::name( ) const
 136 {
 137         if( key_ > 0 )
 138                 {
 139                         ReverseTableType::const_iterator i = reverseTable.find( key_ );
 140                         if( i == reverseTable.end( ) )
 141                                 {
 142                                         throw Exceptions::InternalError( "The reverse symbol table did not include the sought key." );
 143                                 }
 144                         return i->second;
 145                 }
 146         else if( key_ < 0 )
 147                 {
 148                         return strrefdup( "<unique>" );
 149                 }
 150         return strrefdup( "<dummy>" );
 151 }
 152
 153 RefCountPtr< const char >
 154 Lang::Symbol::nameFromKey( KeyType key )
 155 {
 156         if( key <= 0 )
 157                 {
 158                         throw Exceptions::MiscellaneousRequirement( "If is forbidden to ask for the name of a unique symbol." );
 159                 }
 160         ReverseTableType::const_iterator i = reverseTable.find( key );
 161         if( i == reverseTable.end( ) )
 162                 {
 163                         throw Exceptions::InternalError( "The reverse symbol table did not include the sought key." );
 164                 }
 165         return i->second;
 166 }
 167
 168
 169 RefCountPtr< const Lang::Class > Lang::Symbol::TypeID( new Lang::SystemFinalClass( strrefdup( "Symbol" ) ) );
 170 TYPEINFOIMPL( Symbol );
 171
 172 void
 173 Lang::Symbol::show( std::ostream & os ) const
 174 {
 175         if( isUnique( ) )
 176                 {
 177                         os << "< unique >" ;
 178                 }
 179         else
 180                 {
 181                         os << name( ) ;
 182                 }
 183 }
 184
 185
 186 DISPATCHIMPL( Float );
 187
 188 RefCountPtr< const Lang::Class > Lang::Float::TypeID( new Lang::SystemFinalClass( strrefdup( "Float" ) ) );
 189 TYPEINFOIMPL( Float );
 190
 191 void
 192 Lang::Float::show( std::ostream & os ) const
 193 {
 194         os << val_ ;
 195 }
 196
 197
 198 DISPATCHIMPL( Int );
 199
 200 RefCountPtr< const Lang::Class > Lang::Integer::TypeID( new Lang::SystemFinalClass( strrefdup( "Integer" ) ) );
 201 TYPEINFOIMPL( Integer );
 202
 203 void
 204 Lang::Integer::show( std::ostream & os ) const
 205 {
 206         os << "'" << val_ ;
 207 }
 208
 209 /*
 210 Lang::Length::Length( double val )
 211         : isOffset_( false ), val_( val )
 212 { }
 213
 214 Lang::Length::Length( bool isOffset, double val )
 215         : isOffset_( _isOffset ), val_( _val )
 216 { }
 217 */
 218 DISPATCHIMPL( Length );
 219
 220 Concrete::Length
 221 Lang::Length::get( Concrete::Length baseLength ) const
 222 {
 223         if( isOffset_ )
 224                 {
 225                         return baseLength + val_;
 226                 }
 227         return val_;
 228 }
 229
 230 Concrete::Length
 231 Lang::Length::get( ) const
 232 {
 233         if( isOffset_ )
 234                 {
 235                         throw Exceptions::MiscellaneousRequirement( "Offset lengths are not allowed here." );
 236                 }
 237         return val_;
 238 }
 239
 240 double
 241 Lang::Length::getScalar( Concrete::Length baseLength ) const
 242 {
 243         if( isOffset_ )
 244                 {
 245                         return ( baseLength + val_ ).offtype< 1, 0 >( );
 246                 }
 247         return val_.offtype< 1, 0 >( );
 248 }
 249
 250 double
 251 Lang::Length::getScalar( ) const
 252 {
 253         if( isOffset_ )
 254                 {
 255                         throw Exceptions::MiscellaneousRequirement( "Offset lengths are not allowed here." );
 256                 }
 257         return val_.offtype< 1, 0 >( );
 258 }
 259
 260 Lang::Length
 261 Lang::Length::operator + ( const Lang::Length & term ) const
 262 {
 263         if( term.isOffset_ )
 264                 {
 265                         throw Exceptions::MiscellaneousRequirement( "The right term in a length addition must not be offset." );
 266                 }
 267         return Lang::Length( isOffset_, val_ + term.val_ );
 268 }
 269
 270 Lang::Length
 271 Lang::Length::operator - ( const Lang::Length & term ) const
 272 {
 273         if( term.isOffset_ )
 274                 {
 275                         throw Exceptions::MiscellaneousRequirement( "The right term in a length subtraction must not be offset." );
 276                 }
 277         return Lang::Length( isOffset_, val_ - term.val_ );
 278 }
 279
 280 RefCountPtr< const Lang::Class > Lang::Length::TypeID( new Lang::SystemFinalClass( strrefdup( "Length" ) ) );
 281 TYPEINFOIMPL( Length );
 282
 283 void
 284 Lang::Length::show( std::ostream & os ) const
 285 {
 286         os << *this ;
 287 }
 288
 289
 290 std::ostream &
 291 Lang::operator << ( std::ostream & os, const Lang::Length & self )
 292 {
 293         if( self.isOffset_ )
 294                 {
 295                         os << "(+" ;
 296                 }
 297         os << self.val_ / Interaction::displayUnit << Interaction::displayUnitName ;
 298         if( self.isOffset_ )
 299                 {
 300                         os << ")" ;
 301                 }
 302         return os;
 303 }
 304
 305
 306 DISPATCHIMPL( Boolean );
 307
 308 RefCountPtr< const Lang::Class > Lang::Boolean::TypeID( new Lang::SystemFinalClass( strrefdup( "Boolean" ) ) );
 309 TYPEINFOIMPL( Boolean );
 310
 311 void
 312 Lang::Boolean::show( std::ostream & os ) const
 313 {
 314         if( val_ )
 315                 {
 316                         os << "true" ;
 317                 }
 318         else
 319                 {
 320                         os << "false" ;
 321                 }
 322 }
 323
 324
 325 Lang::String::~String( )
 326 { }
 327
 328 DISPATCHIMPL( String );
 329
 330 RefCountPtr< const Lang::Class > Lang::String::TypeID( new Lang::SystemFinalClass( strrefdup( "String" ) ) );
 331 TYPEINFOIMPL( String );
 332
 333 Kernel::VariableHandle
 334 Lang::String::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 335 {
 336         if( strcmp( fieldID, "bytecount" ) == 0 )
 337                 {
 338                         return Helpers::newValHandle( new Lang::Integer( bytecount_ ) );
 339                 }
 340         if( strcmp( fieldID, "UTF8?" ) == 0 )
 341                 {
 342                         const unsigned char * src = reinterpret_cast< const unsigned char * >( val_.getPtr( ) );
 343                         const unsigned char * end = src + bytecount_;
 344                         bool res = true;
 345                         for( ; src < end; ++src )
 346                                 {
 347                                         if( ( ( *src ^ 0x00 ) & 0x80 ) == 0 )
 348                                                 {
 349                                                         continue;
 350                                                 }
 351                                         if( ( ( *src ^ 0xC0 ) & 0xE0 ) == 0 )
 352                                                 {
 353                                                         ++src;
 354                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 355                                                                 {
 356                                                                         res = false;
 357                                                                         break;
 358                                                                 }
 359                                                         continue;
 360                                                 }
 361                                         if( ( ( *src ^ 0xE0 ) & 0xF0 ) == 0 )
 362                                                 {
 363                                                         ++src;
 364                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 365                                                                 {
 366                                                                         res = false;
 367                                                                         break;
 368                                                                 }
 369                                                         ++src;
 370                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 371                                                                 {
 372                                                                         res = false;
 373                                                                         break;
 374                                                                 }
 375                                                         continue;
 376                                                 }
 377                                         if( ( ( *src ^ 0xE0 ) & 0xF8 ) == 0 )
 378                                                 {
 379                                                         ++src;
 380                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 381                                                                 {
 382                                                                         res = false;
 383                                                                         break;
 384                                                                 }
 385                                                         ++src;
 386                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 387                                                                 {
 388                                                                         res = false;
 389                                                                         break;
 390                                                                 }
 391                                                         ++src;
 392                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 393                                                                 {
 394                                                                         res = false;
 395                                                                         break;
 396                                                                 }
 397                                                         continue;
 398                                                 }
 399                                         res = false;
 400                                         break;
 401                                 }
 402                         if( src != end || *src != '\0' )
 403                                 {
 404                                         res = false;
 405                                 }
 406                         return Helpers::newValHandle( new Lang::Boolean( res ) );
 407                 }
 408         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 409 }
 410
 411 void
 412 Lang::String::show( std::ostream & os ) const
 413 {
 414         os << val_.getPtr( ) ;
 415 }
 416
 417
 418 Lang::Continuation::Continuation( const Kernel::ContRef & cont )
 419         : cont_( cont )
 420 { }
 421
 422 Lang::Continuation::~Continuation( )
 423 { }
 424
 425 RefCountPtr< const Lang::Class > Lang::Continuation::TypeID( new Lang::SystemFinalClass( strrefdup( "Backtrace" ) ) );
 426 TYPEINFOIMPL( Continuation );
 427
 428 Kernel::VariableHandle
 429 Lang::Continuation::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 430 {
 431         if( strcmp( fieldID, "up" ) == 0 )
 432                 {
 433                         Kernel::ContRef res = cont_->up( );
 434                         if( res == NullPtr< Kernel::Continuation >( ) )
 435                                 {
 436                                         throw Exceptions::MiscellaneousRequirement( "The top continuation has no parent." );
 437                                 }
 438                         return Helpers::newValHandle( new Lang::Continuation( res ) );
 439                 }
 440         else if( strcmp( fieldID, "top?" ) == 0 )
 441                 {
 442                         Kernel::ContRef res = cont_->up( );
 443                         return ( res == NullPtr< Kernel::Continuation >( ) ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
 444                 }
 445         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 446 }
 447
 448 void
 449 Lang::Continuation::show( std::ostream & os ) const
 450 {
 451         os << "( backtrace to use in error messages )" ;
 452 }
 453
 454 void
 455 Lang::Continuation::gcMark( Kernel::GCMarkedSet & marked )
 456 {
 457         cont_->gcMark( marked );
 458 }
 459
 460
 461 Lang::Exception::Exception( const Ast::SourceLocation & loc, const RefCountPtr< const Lang::Symbol > & kind, const RefCountPtr< const Lang::String > & source, const RefCountPtr< const Lang::Value > & details, const RefCountPtr< const char > & message, const Kernel::ContRef & cont, Interaction::ExitCode exitCode )
 462         : loc_( loc ), kind_( kind ), source_( source ), details_( details ), message_( message ), cont_( cont ), exitCode_( exitCode )
 463 { }
 464
 465 Lang::Exception::Exception( const RefCountPtr< const Lang::Symbol > & kind, const RefCountPtr< const Lang::String > & source, const RefCountPtr< const Lang::Value > & details, const RefCountPtr< const char > & message, const Kernel::ContRef & cont, Interaction::ExitCode exitCode )
 466         : loc_( cont->traceLoc( ) ), kind_( kind ), source_( source ), details_( details ), message_( message ), cont_( cont ), exitCode_( exitCode )
 467 { }
 468
 469 Lang::Exception::~Exception( )
 470 { }
 471
 472 RefCountPtr< const Lang::Class > Lang::Exception::TypeID( new Lang::SystemFinalClass( strrefdup( "Exception" ) ) );
 473 TYPEINFOIMPL( Exception );
 474
 475 Kernel::VariableHandle
 476 Lang::Exception::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 477 {
 478         if( strcmp( fieldID, "kind" ) == 0 )
 479                 {
 480                         return Kernel::VariableHandle( new Kernel::Variable( kind_ ) );
 481                 }
 482         else if( strcmp( fieldID, "source" ) == 0 )
 483                 {
 484                         return Kernel::VariableHandle( new Kernel::Variable( source_ ) );
 485                 }
 486         else if( strcmp( fieldID, "details" ) == 0 )
 487                 {
 488                         return Kernel::VariableHandle( new Kernel::Variable( details_ ) );
 489                 }
 490         else if( strcmp( fieldID, "backtrace" ) == 0 )
 491                 {
 492                         return Helpers::newValHandle( new Lang::Continuation( cont_ ) );
 493                 }
 494         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 495 }
 496
 497 void
 498 Lang::Exception::show( std::ostream & os ) const
 499 {
 500         os << message_ ;
 501 }
 502
 503 void
 504 Lang::Exception::gcMark( Kernel::GCMarkedSet & marked )
 505 {
 506         const_cast< Lang::Value * >( details_.getPtr( ) )->gcMark( marked );
 507         const_cast< Kernel::Continuation * >( cont_.getPtr( ) )->gcMark( marked );
 508 }
 509
 510
 511 Lang::FloatPair::FloatPair( const Concrete::UnitFloatPair & orig )
 512         : x_( orig.x_ ), y_( orig.y_ )
 513 { }
 514
 515
 516 DISPATCHIMPL( FloatPair );
 517
 518 Kernel::VariableHandle
 519 Lang::FloatPair::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 520 {
 521         if( strcmp( fieldID, "x" ) == 0 )
 522                 {
 523                         return Helpers::newValHandle( new Lang::Float( x_ ) );
 524                 }
 525         if( strcmp( fieldID, "y" ) == 0 )
 526                 {
 527                         return Helpers::newValHandle( new Lang::Float( y_ ) );
 528                 }
 529         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 530 }
 531
 532 RefCountPtr< const Lang::Class > Lang::FloatPair::TypeID( new Lang::SystemFinalClass( strrefdup( "FloatPair" ) ) );
 533 TYPEINFOIMPL( FloatPair );
 534
 535 RefCountPtr< const Lang::FloatPair >
 536 Lang::FloatPair::transformed( const Lang::Transform2D & tf ) const
 537 {
 538         return RefCountPtr< const Lang::FloatPair >
 539                 ( new Lang::FloatPair( tf.xx_ * x_ + tf.xy_ * y_, tf.yx_ * x_ + tf.yy_ * y_ ) );
 540 }
 541
 542 void
 543 Lang::FloatPair::show( std::ostream & os ) const
 544 {
 545         os << "( " << x_ << ", " << y_ << " )" ;
 546 }
 547
 548 Lang::FloatTriple::FloatTriple( const Concrete::UnitFloatTriple & orig )
 549         : x_( orig.x_ ), y_( orig.y_ ), z_( orig.z_ )
 550 { }
 551
 552 DISPATCHIMPL( FloatTriple );
 553
 554 Kernel::VariableHandle
 555 Lang::FloatTriple::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 556 {
 557         if( strcmp( fieldID, "x" ) == 0 )
 558                 {
 559                         return Helpers::newValHandle( new Lang::Float( x_ ) );
 560                 }
 561         if( strcmp( fieldID, "y" ) == 0 )
 562                 {
 563                         return Helpers::newValHandle( new Lang::Float( y_ ) );
 564                 }
 565         if( strcmp( fieldID, "z" ) == 0 )
 566                 {
 567                         return Helpers::newValHandle( new Lang::Float( z_ ) );
 568                 }
 569         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 570 }
 571
 572 RefCountPtr< const Lang::Class > Lang::FloatTriple::TypeID( new Lang::SystemFinalClass( strrefdup( "FloatTriple" ) ) );
 573 TYPEINFOIMPL( FloatTriple );
 574
 575 RefCountPtr< const Lang::FloatTriple >
 576 Lang::FloatTriple::transformed( const Lang::Transform3D & tf ) const
 577 {
 578         return RefCountPtr< const Lang::FloatTriple >
 579                 ( new Lang::FloatTriple( tf.xx_ * x_ + tf.xy_ * y_ + tf.xz_ * z_,
 580                                                                                                                  tf.yx_ * x_ + tf.yy_ * y_ + tf.yz_ * z_,
 581                                                                                                                  tf.zx_ * x_ + tf.zy_ * y_ + tf.zz_ * z_ ) );
 582 }
 583
 584 void
 585 Lang::FloatTriple::show( std::ostream & os ) const
 586 {
 587         os << "( " << x_ << ", " << y_ << ", " << z_ << " )" ;
 588 }
 589
 590
 591 Lang::Coords2D::Coords2D( const Lang::Coords2D & orig )
 592         : x_( orig.x_ ), y_( orig.y_ )
 593 { }
 594
 595 Lang::Coords2D::Coords2D( const Lang::Length & x, const Lang::Length & y )
 596         : x_( x ), y_( y )
 597 { }
 598
 599 Lang::Coords2D::Coords2D( const Concrete::Length & x, const Concrete::Length & y )
 600         : x_( x ), y_( y )
 601 { }
 602
 603 DISPATCHIMPL( Coords2D );
 604
 605 Kernel::VariableHandle
 606 Lang::Coords2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 607 {
 608         if( strcmp( fieldID, "x" ) == 0 )
 609                 {
 610                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 611                 }
 612         if( strcmp( fieldID, "y" ) == 0 )
 613                 {
 614                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 615                 }
 616         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 617 }
 618
 619 Lang::Coords2D *
 620 Lang::Coords2D::transformedPtr( const Lang::Transform2D & tf ) const
 621 {
 622         Concrete::Length tmpx = x_.get( );
 623         Concrete::Length tmpy = y_.get( );
 624         return new Lang::Coords2D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xt_, tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yt_ );
 625 }
 626
 627 RefCountPtr< const Lang::Geometric2D >
 628 Lang::Coords2D::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
 629 {
 630         return RefCountPtr< const Lang::Geometric2D >( transformedPtr( tf ) );
 631 }
 632
 633 RefCountPtr< const Lang::Geometric3D >
 634 Lang::Coords2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 635 {
 636         return RefCountPtr< const Lang::Coords3D >( new Lang::Coords3D( x_, y_, Lang::Length( Concrete::Length( 0 ) ) ) );
 637 }
 638
 639 RefCountPtr< const Lang::Class > Lang::Coords2D::TypeID( new Lang::SystemFinalClass( strrefdup( "Coords2D" ) ) );
 640 TYPEINFOIMPL( Coords2D );
 641
 642 void
 643 Lang::Coords2D::show( std::ostream & os ) const
 644 {
 645         os << "( " << x_ << ", " << y_ << " )" ;
 646 }
 647
 648 std::ostream &
 649 Lang::operator << ( std::ostream & os, const Lang::Coords2D & self )
 650 {
 651         os << "( " << self.x_ << ", " << self.y_ << " )" ;
 652         return os;
 653 }
 654
 655
 656 Lang::CornerCoords2D::CornerCoords2D( const Lang::Length & x, const Lang::Length & y, double a )
 657         : Lang::Coords2D( x, y ), a_( a )
 658 { }
 659
 660 Lang::CornerCoords2D::CornerCoords2D( const Concrete::Length & x, const Concrete::Length & y, double a )
 661         : Lang::Coords2D( x, y ), a_( a )
 662 { }
 663
 664 RefCountPtr< const Lang::Class > Lang::CornerCoords2D::TypeID( new Lang::SystemFinalClass( strrefdup( "CornerCoords2D" ) ) );
 665 DISPATCHIMPL( CornerCoords2D );
 666
 667 Kernel::VariableHandle
 668 Lang::CornerCoords2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 669 {
 670         if( strcmp( fieldID, "x" ) == 0 )
 671                 {
 672                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 673                 }
 674         if( strcmp( fieldID, "y" ) == 0 )
 675                 {
 676                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 677                 }
 678         if( strcmp( fieldID, "a" ) == 0 )
 679                 {
 680                         return Helpers::newValHandle( new Lang::Float( a_ ) );
 681                 }
 682         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 683 }
 684
 685 Lang::CornerCoords2D *
 686 Lang::CornerCoords2D::transformedPtr( const Lang::Transform2D & tf ) const
 687 {
 688         Concrete::Length tmpx = x_.get( );
 689         Concrete::Length tmpy = y_.get( );
 690         return new Lang::CornerCoords2D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xt_, tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yt_, a_ );
 691 }
 692
 693 RefCountPtr< const Lang::Geometric2D >
 694 Lang::CornerCoords2D::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
 695 {
 696         return RefCountPtr< const Lang::Geometric2D >( transformedPtr( tf ) );
 697 }
 698
 699 RefCountPtr< const Lang::Geometric3D >
 700 Lang::CornerCoords2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 701 {
 702         throw Exceptions::MiscellaneousRequirement( "Corner coordinates cannot move into 3D space." );
 703 }
 704
 705 TYPEINFOIMPL( CornerCoords2D );
 706
 707
 708 Lang::Coords3D::Coords3D( const Lang::Coords3D & orig )
 709         : x_( orig.x_ ), y_( orig.y_ ), z_( orig.z_ )
 710 { }
 711
 712 Lang::Coords3D::Coords3D( const Lang::Length & x, const Lang::Length & y, const Lang::Length & z )
 713         : x_( x ), y_( y ), z_( z )
 714 { }
 715
 716 Lang::Coords3D::Coords3D( const Concrete::Length & x, const Concrete::Length & y, const Concrete::Length & z )
 717         : x_( x ), y_( y ), z_( z )
 718 { }
 719
 720 DISPATCHIMPL( Coords3D );
 721
 722 Kernel::VariableHandle
 723 Lang::Coords3D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 724 {
 725         if( strcmp( fieldID, "x" ) == 0 )
 726                 {
 727                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 728                 }
 729         if( strcmp( fieldID, "y" ) == 0 )
 730                 {
 731                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 732                 }
 733         if( strcmp( fieldID, "z" ) == 0 )
 734                 {
 735                         return Helpers::newValHandle( new Lang::Length( z_ ) );
 736                 }
 737         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 738 }
 739
 740 Lang::Coords3D *
 741 Lang::Coords3D::transformedPtr( const Lang::Transform3D & tf ) const
 742 {
 743         Concrete::Length tmpx = x_.get( );
 744         Concrete::Length tmpy = y_.get( );
 745         Concrete::Length tmpz = z_.get( );
 746         return new Lang::Coords3D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xz_ * tmpz + tf.xt_,
 747                                                                                                                  tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yz_ * tmpz + tf.yt_,
 748                                                                                                                  tf.zx_ * tmpx + tf.zy_ * tmpy + tf.zz_ * tmpz + tf.zt_ );
 749 }
 750
 751 RefCountPtr< const Lang::Geometric3D >
 752 Lang::Coords3D::transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const
 753 {
 754         return RefCountPtr< const Lang::Geometric3D >( transformedPtr( tf ) );
 755 }
 756
 757 RefCountPtr< const Lang::Coords2D >
 758 Lang::Coords3D::make2D( Concrete::Length eyez ) const
 759 {
 760         if( eyez < Concrete::HUGE_LENGTH )
 761                 {
 762                         return RefCountPtr< const Lang::Coords2D >( new Lang::Coords2D( x_.get( ) * ( eyez / ( eyez - z_.get( ) ) ),
 763                                                                                                                                                                                                                                                                                         y_.get( ) * ( eyez / ( eyez - z_.get( ) ) ) ) );
 764                 }
 765         return RefCountPtr< const Lang::Coords2D >( new Lang::Coords2D( x_.get( ),
 766                                                                                                                                                                                                                                                                         y_.get( ) ) );
 767 }
 768
 769
 770 RefCountPtr< const Lang::Geometric2D >
 771 Lang::Coords3D::to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const
 772 {
 773         return make2D( dyn->getEyeZ( ) );
 774 }
 775
 776 RefCountPtr< const Lang::Class > Lang::Coords3D::TypeID( new Lang::SystemFinalClass( strrefdup( "Coords3D" ) ) );
 777 TYPEINFOIMPL( Coords3D );
 778
 779 void
 780 Lang::Coords3D::show( std::ostream & os ) const
 781 {
 782         os << "( " << x_ << ", " << y_ << ", " << z_ << " )" ;
 783 }
 784
 785 std::ostream &
 786 Lang::operator << ( std::ostream & os, const Lang::Coords3D & self )
 787 {
 788         os << "( " << self.x_ << ", " << self.y_ << ", " << self.z_ << " )" ;
 789         return os;
 790 }