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, 2013, 2014 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 #include "singlelistrange.h"
  31 #include "continuations.h"
  32 #include "methodbase.h"
  33
  34 #include <ctype.h>
  35 #include <stack>
  36
  37 using namespace Shapes;
  38 using namespace std;
  39
  40
  41 Lang::Symbol::NameTableType Lang::Symbol::nameTable;
  42 Lang::Symbol::ReverseTableType Lang::Symbol::reverseTable;
  43 int Lang::Symbol::nextUnique = -1;
  44
  45 /* 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.
  46  */
  47 RefCountPtr< const Lang::Symbol > Kernel::THE_NAVIGATION_SYMBOL( ".navigation" ); /* Note that the leading dot puts this symbol aside all user-symbols. */
  48 RefCountPtr< const Lang::Symbol > Kernel::THE_ANNOTATION_SYMBOL( ".annotation" ); /* Note that the leading dot puts this symbol aside all user-symbols. */
  49
  50 Lang::Symbol::Symbol( )
  51 {
  52         key_ = nextUnique;
  53         --nextUnique;
  54 }
  55
  56 DISPATCHIMPL( Symbol );
  57
  58 Lang::Symbol::Symbol( int key )
  59 {
  60         if( key != 0 )
  61                 {
  62                         throw Exceptions::InternalError( "Only the key 0 may be used when creating symbols with a given key." );
  63                 }
  64         key_ = 0;
  65 }
  66
  67 Lang::Symbol::Symbol( const char * name )
  68 {
  69         NameTableType::const_iterator i = nameTable.find( name );
  70         if( i != nameTable.end( ) )
  71                 {
  72                         key_ = i->second;
  73                 }
  74         else
  75                 {
  76                         const char * nameCopy = strdup( name );
  77                         key_ = nameTable.size( ) + 1;
  78                         nameTable[ nameCopy ] = key_;
  79                         reverseTable.insert( ReverseTableType::value_type( key_, RefCountPtr< const char >( nameCopy ) ) );
  80                 }
  81 }
  82
  83 bool
  84 Lang::Symbol::operator == ( const Symbol & other ) const
  85 {
  86         return key_ == other.key_;
  87 }
  88
  89 bool
  90 Lang::Symbol::operator != ( const Symbol & other ) const
  91 {
  92         return key_ != other.key_;
  93 }
  94
  95 bool
  96 Lang::Symbol::operator < ( const Symbol & other ) const
  97 {
  98         return key_ < other.key_;
  99 }
 100
 101 bool
 102 Lang::Symbol::operator > ( const Symbol & other ) const
 103 {
 104         return key_ > other.key_;
 105 }
 106
 107 bool
 108 Lang::Symbol::operator <= ( const Symbol & other ) const
 109 {
 110         return key_ <= other.key_;
 111 }
 112
 113 bool
 114 Lang::Symbol::operator >= ( const Symbol & other ) const
 115 {
 116         return key_ >= other.key_;
 117 }
 118
 119 bool
 120 Lang::Symbol::isUnique( ) const
 121 {
 122         return key_ < 0;
 123 }
 124
 125 RefCountPtr< const char >
 126 Lang::Symbol::name( ) const
 127 {
 128         if( key_ > 0 )
 129                 {
 130                         ReverseTableType::const_iterator i = reverseTable.find( key_ );
 131                         if( i == reverseTable.end( ) )
 132                                 {
 133                                         throw Exceptions::InternalError( "The reverse symbol table did not include the sought key." );
 134                                 }
 135                         return i->second;
 136                 }
 137         else if( key_ < 0 )
 138                 {
 139                         return strrefdup( "<unique>" );
 140                 }
 141         return strrefdup( "<dummy>" );
 142 }
 143
 144 RefCountPtr< const char >
 145 Lang::Symbol::nameFromKey( KeyType key )
 146 {
 147         if( key <= 0 )
 148                 {
 149                         throw Exceptions::MiscellaneousRequirement( "It is forbidden to ask for the name of a unique symbol." );
 150                 }
 151         ReverseTableType::const_iterator i = reverseTable.find( key );
 152         if( i == reverseTable.end( ) )
 153                 {
 154                         throw Exceptions::InternalError( "The reverse symbol table did not include the sought key." );
 155                 }
 156         return i->second;
 157 }
 158
 159
 160 RefCountPtr< const Lang::Class > Lang::Symbol::TypeID( new Lang::SystemFinalClass( strrefdup( "Symbol" ) ) );
 161 TYPEINFOIMPL( Symbol );
 162
 163 void
 164 Lang::Symbol::show( std::ostream & os ) const
 165 {
 166         if( isUnique( ) )
 167                 {
 168                         os << "'<unique>" ;
 169                 }
 170         else
 171                 {
 172                         os << "'" << name( ) ;
 173                 }
 174 }
 175
 176
 177 DISPATCHIMPL( Float );
 178
 179 RefCountPtr< const Lang::Class > Lang::Float::TypeID( new Lang::SystemFinalClass( strrefdup( "Float" ) ) );
 180 TYPEINFOIMPL( Float );
 181
 182 void
 183 Lang::Float::show( std::ostream & os ) const
 184 {
 185         if( val_ >= 0.0 ){
 186                 os << val_ ;
 187         }else{
 188                 os << "~" << -val_ ;
 189         }
 190 }
 191
 192
 193 DISPATCHIMPL( Integer );
 194
 195 RefCountPtr< const Lang::Class > Lang::Integer::TypeID( new Lang::SystemFinalClass( strrefdup( "Integer" ) ) );
 196 TYPEINFOIMPL( Integer );
 197
 198 bool
 199 Lang::Integer::operator == ( const Integer & other ) const
 200 {
 201         return val_ == other.val_;
 202 }
 203
 204 bool
 205 Lang::Integer::operator != ( const Integer & other ) const
 206 {
 207         return val_ != other.val_;
 208 }
 209
 210 bool
 211 Lang::Integer::operator < ( const Integer & other ) const
 212 {
 213         return val_ < other.val_;
 214 }
 215
 216 bool
 217 Lang::Integer::operator > ( const Integer & other ) const
 218 {
 219         return val_ > other.val_;
 220 }
 221
 222 bool
 223 Lang::Integer::operator <= ( const Integer & other ) const
 224 {
 225         return val_ <= other.val_;
 226 }
 227
 228 bool
 229 Lang::Integer::operator >= ( const Integer & other ) const
 230 {
 231         return val_ >= other.val_;
 232 }
 233
 234 Kernel::VariableHandle
 235 Lang::Integer::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 236 {
 237         if( strcmp( fieldID, "hex" ) == 0 )
 238                 {
 239                         std::ostringstream oss;
 240                         ValueType tmp = val_;
 241                         if( tmp < 0 )
 242                                 {
 243                                         oss << "~" ;
 244                                         tmp = -tmp;
 245                                 }
 246                         oss << std::hex << tmp ;
 247                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 248                 }
 249         if( strcmp( fieldID, "oct" ) == 0 )
 250                 {
 251                         std::ostringstream oss;
 252                         ValueType tmp = val_;
 253                         if( tmp < 0 )
 254                                 {
 255                                         oss << "~" ;
 256                                         tmp = -tmp;
 257                                 }
 258                         oss << std::oct << tmp ;
 259                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 260                 }
 261         if( strcmp( fieldID, "bin" ) == 0 )
 262                 {
 263                         std::ostringstream oss;
 264                         ValueType tmp = val_;
 265                         if( tmp < 0 )
 266                                 {
 267                                         oss << "~" ;
 268                                         tmp = -tmp;
 269                                 }
 270                         char buf[ 8 * sizeof( ValueType ) ]; /* Since ValueType is signed, there is enough memory to hold the terminating null character. */
 271                         char * dst = buf;
 272                         ValueType twopow = 1;
 273                         while( twopow < tmp )
 274                                 {
 275                                         twopow *= 2;
 276                                 }
 277                         for( ; twopow > 0; twopow /= 2, ++dst )
 278                                 {
 279                                         if( tmp >= twopow )
 280                                                 {
 281                                                         *dst = '1';
 282                                                         tmp -= twopow;
 283                                                 }
 284                                         else
 285                                                 {
 286                                                         *dst = '0';
 287                                                 }
 288                                 }
 289                         *dst = '\0';
 290                         oss << buf ;
 291                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 292                 }
 293         if( strcmp( fieldID, "bits_bin" ) == 0 )
 294                 {
 295                         std::ostringstream oss;
 296                         ValueType_unsigned tmp = *reinterpret_cast< const ValueType_unsigned * >( & val_ );
 297                         char buf[ 8 * sizeof( ValueType ) + 1];
 298                         char * dst = buf + 8 * sizeof( ValueType );
 299                         *dst = '\0';
 300                         for( ; dst > buf; )
 301                                 {
 302                                         --dst;
 303                                         *dst = ( ( tmp % 2 ) != 0 ) ? '1': '0';
 304                                         tmp /= 2;
 305                                 }
 306                         oss << buf ;
 307                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 308                 }
 309         if( strcmp( fieldID, "bits_hex" ) == 0 )
 310                 {
 311                         std::ostringstream oss;
 312                         ValueType_unsigned tmp = *reinterpret_cast< const ValueType_unsigned * >( & val_ );
 313                         char buf[ 2 * sizeof( ValueType ) + 1];
 314                         char * dst = buf + 2 * sizeof( ValueType );
 315                         *dst = '\0';
 316                         for( ; dst > buf; )
 317                                 {
 318                                         --dst;
 319                                         unsigned char d = tmp % 0x10;
 320                                         if( d < 10 )
 321                                                 {
 322                                                         *dst = '0' + d;
 323                                                 }
 324                                         else
 325                                                 {
 326                                                         *dst = 'A' + ( d - 10 );
 327                                                 }
 328                                         tmp /= 0x10;
 329                                 }
 330                         oss << buf ;
 331                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 332                 }
 333         if( strcmp( fieldID, "dec" ) == 0 )
 334                 {
 335                         std::ostringstream oss;
 336                         ValueType tmp = val_;
 337                         if( tmp < 0 )
 338                                 {
 339                                         oss << "~" ;
 340                                         tmp = -tmp;
 341                                 }
 342                         oss << std::dec << tmp ;
 343                         return Helpers::newValHandle( new Lang::String( strrefdup( oss ) ) );
 344                 }
 345
 346         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 347 }
 348
 349 void
 350 Lang::Integer::show( std::ostream & os ) const
 351 {
 352         if( val_ >= 0 ){
 353                 os << "'" << val_ ;
 354         }else{
 355                 os << "'~" << -val_ ;
 356         }
 357 }
 358
 359 DISPATCHIMPL( Character );
 360
 361 RefCountPtr< const Lang::Class > Lang::Character::TypeID( new Lang::SystemFinalClass( strrefdup( "Character" ) ) );
 362 TYPEINFOIMPL( Character );
 363
 364 void
 365 Lang::Character::show( std::ostream & os ) const
 366 {
 367         const size_t bufSize = 8;
 368         char buf[ bufSize ];
 369         char * dst = buf;
 370         size_t out_avail = bufSize - 1;
 371         val_.encode_UTF8( & dst, & out_avail );
 372         *dst = '\0';
 373         os << buf ;
 374 }
 375
 376 Kernel::VariableHandle
 377 Lang::Character::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 378 {
 379         if( strcmp( fieldID, "code" ) == 0 )
 380                 {
 381                         return Helpers::newValHandle( new Lang::Integer( val_.get_UCS4( ) ) );
 382                 }
 383
 384         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 385 }
 386
 387
 388 //Lang::Length::Length( double val )
 389 //      : isOffset_( false ), val_( val )
 390 //{ }
 391 //
 392 //Lang::Length::Length( bool isOffset, double val )
 393 //      : isOffset_( _isOffset ), val_( _val )
 394 //{ }
 395
 396 DISPATCHIMPL( Length );
 397
 398 Concrete::Length
 399 Lang::Length::get( Concrete::Length baseLength ) const
 400 {
 401         if( isOffset_ )
 402                 {
 403                         return baseLength + val_;
 404                 }
 405         return val_;
 406 }
 407
 408 Concrete::Length
 409 Lang::Length::get( ) const
 410 {
 411         if( isOffset_ )
 412                 {
 413                         throw Exceptions::MiscellaneousRequirement( "Offset lengths are not allowed here." );
 414                 }
 415         return val_;
 416 }
 417
 418 double
 419 Lang::Length::getScalar( Concrete::Length baseLength ) const
 420 {
 421         if( isOffset_ )
 422                 {
 423                         return ( baseLength + val_ ).offtype< 1, 0 >( );
 424                 }
 425         return val_.offtype< 1, 0 >( );
 426 }
 427
 428 double
 429 Lang::Length::getScalar( ) const
 430 {
 431         if( isOffset_ )
 432                 {
 433                         throw Exceptions::MiscellaneousRequirement( "Offset lengths are not allowed here." );
 434                 }
 435         return val_.offtype< 1, 0 >( );
 436 }
 437
 438 Lang::Length
 439 Lang::Length::operator + ( const Lang::Length & term ) const
 440 {
 441         if( term.isOffset_ )
 442                 {
 443                         throw Exceptions::MiscellaneousRequirement( "The right term in a length addition must not be offset." );
 444                 }
 445         return Lang::Length( isOffset_, val_ + term.val_ );
 446 }
 447
 448 Lang::Length
 449 Lang::Length::operator - ( const Lang::Length & term ) const
 450 {
 451         if( term.isOffset_ )
 452                 {
 453                         throw Exceptions::MiscellaneousRequirement( "The right term in a length subtraction must not be offset." );
 454                 }
 455         return Lang::Length( isOffset_, val_ - term.val_ );
 456 }
 457
 458 RefCountPtr< const Lang::Class > Lang::Length::TypeID( new Lang::SystemFinalClass( strrefdup( "Length" ) ) );
 459 TYPEINFOIMPL( Length );
 460
 461 void
 462 Lang::Length::show( std::ostream & os ) const
 463 {
 464         os << *this ;
 465 }
 466
 467
 468 std::ostream &
 469 Lang::operator << ( std::ostream & os, const Lang::Length & self )
 470 {
 471         if( self.isOffset_ )
 472                 {
 473                         os << "(+" ;
 474                 }
 475         double lengthVal = static_cast< double >( self.val_ / Interaction::displayUnit );
 476         if( lengthVal >= 0 ){
 477                 os << lengthVal ;
 478         }else{
 479                 os << "~" << -lengthVal ;
 480         }
 481         os << Interaction::displayUnitName ;
 482         if( self.isOffset_ )
 483                 {
 484                         os << ")" ;
 485                 }
 486         return os;
 487 }
 488
 489
 490 DISPATCHIMPL( Boolean );
 491
 492 RefCountPtr< const Lang::Class > Lang::Boolean::TypeID( new Lang::SystemFinalClass( strrefdup( "Boolean" ) ) );
 493 TYPEINFOIMPL( Boolean );
 494
 495 void
 496 Lang::Boolean::show( std::ostream & os ) const
 497 {
 498         if( val_ )
 499                 {
 500                         os << "true" ;
 501                 }
 502         else
 503                 {
 504                         os << "false" ;
 505                 }
 506 }
 507
 508
 509 namespace Shapes
 510 {
 511
 512         namespace Lang
 513         {
 514
 515                 class StringMethod_byteselect : public Lang::MethodBase< Lang::String >
 516                 {
 517                 public:
 518                         StringMethod_byteselect( RefCountPtr< const Lang::String > _self, const Ast::FileID * fullMethodID );
 519                         virtual ~StringMethod_byteselect( );
 520                         virtual void call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const;
 521                         static const char * staticFieldID( ) { return "byteselect"; }
 522                 };
 523
 524                 class StringMethod_UTF8select : public Lang::MethodBase< Lang::String >
 525                 {
 526                 public:
 527                         StringMethod_UTF8select( RefCountPtr< const Lang::String > _self, const Ast::FileID * fullMethodID );
 528                         virtual ~StringMethod_UTF8select( );
 529                         virtual void call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const;
 530                         static const char * staticFieldID( ) { return "UTF8select"; }
 531                 };
 532
 533         }
 534 }
 535
 536 void
 537 String_register_methods( Lang::SystemFinalClass * dstClass )
 538 {
 539         dstClass->registerMethod( new Kernel::MethodFactory< Lang::String, Lang::StringMethod_byteselect >( ) );
 540         dstClass->registerMethod( new Kernel::MethodFactory< Lang::String, Lang::StringMethod_UTF8select >( ) );
 541 }
 542
 543 Lang::String::~String( )
 544 { }
 545
 546 DISPATCHIMPL( String );
 547
 548 RefCountPtr< const Lang::Class > Lang::String::TypeID( new Lang::SystemFinalClass( strrefdup( "String" ), String_register_methods ) );
 549 TYPEINFOIMPL( String );
 550
 551 Kernel::VariableHandle
 552 Lang::String::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 553 {
 554         if( strcmp( fieldID, "bytecount" ) == 0 )
 555                 {
 556                         return Helpers::newValHandle( new Lang::Integer( bytecount_ ) );
 557                 }
 558         if( strcmp( fieldID, "UTF8count" ) == 0 )
 559                 {
 560                         return Helpers::newValHandle( new Lang::Integer( UTF8count( ) ) );
 561                 }
 562         if( strcmp( fieldID, "UTF8?" ) == 0 )
 563                 {
 564                         const unsigned char * src = reinterpret_cast< const unsigned char * >( val_.getPtr( ) );
 565                         const unsigned char * end = src + bytecount_;
 566                         bool res = true;
 567                         for( ; src < end; ++src )
 568                                 {
 569                                         if( ( ( *src ^ 0x00 ) & 0x80 ) == 0 )
 570                                                 {
 571                                                         continue;
 572                                                 }
 573                                         if( ( ( *src ^ 0xC0 ) & 0xE0 ) == 0 )
 574                                                 {
 575                                                         ++src;
 576                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 577                                                                 {
 578                                                                         res = false;
 579                                                                         break;
 580                                                                 }
 581                                                         continue;
 582                                                 }
 583                                         if( ( ( *src ^ 0xE0 ) & 0xF0 ) == 0 )
 584                                                 {
 585                                                         ++src;
 586                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 587                                                                 {
 588                                                                         res = false;
 589                                                                         break;
 590                                                                 }
 591                                                         ++src;
 592                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 593                                                                 {
 594                                                                         res = false;
 595                                                                         break;
 596                                                                 }
 597                                                         continue;
 598                                                 }
 599                                         if( ( ( *src ^ 0xE0 ) & 0xF8 ) == 0 )
 600                                                 {
 601                                                         ++src;
 602                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 603                                                                 {
 604                                                                         res = false;
 605                                                                         break;
 606                                                                 }
 607                                                         ++src;
 608                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 609                                                                 {
 610                                                                         res = false;
 611                                                                         break;
 612                                                                 }
 613                                                         ++src;
 614                                                         if( ( ( *src ^ 0x80 ) & 0xC0 ) != 0 )
 615                                                                 {
 616                                                                         res = false;
 617                                                                         break;
 618                                                                 }
 619                                                         continue;
 620                                                 }
 621                                         res = false;
 622                                         break;
 623                                 }
 624                         if( src != end || *src != '\0' )
 625                                 {
 626                                         res = false;
 627                                 }
 628                         return Helpers::newValHandle( new Lang::Boolean( res ) );
 629                 }
 630
 631         return TypeID->getMethod( selfRef, fieldID ); /* This will throw if there is no such method. */
 632 }
 633
 634 size_t
 635 Lang::String::UTF8count( ) const
 636 {
 637         const char * src = val_.getPtr( );
 638         const char * end = src + bytecount_;
 639
 640         const char * ASCIIstart = src;
 641         size_t count = 0;
 642
 643         while( *src > 0 )
 644                 {
 645                 ASCII:
 646                         ++src;
 647                 }
 648
 649         count += src - ASCIIstart;
 650         while( *src != 0 && src < end )
 651                 {
 652                         if( *src > 0 )
 653                                 {
 654                                         ASCIIstart = src;
 655                                         goto ASCII;
 656                                 }
 657                         else
 658                                 {
 659                                         switch( 0xF0 & *src )
 660                                                 {
 661                                                 case 0xE0: src += 3; break;
 662                                                 case 0xF0: src += 4; break;
 663                                                 default:   src += 2; break;
 664                                                 }
 665                                 }
 666                         ++count;
 667                 }
 668         if( *src != 0 || src != end )
 669                 {
 670                         throw Exceptions::MiscellaneousRequirement( "The string is not valid UTF-8, so the number of UTF-8 characters could not be counted." );
 671                 }
 672
 673         return count;
 674 }
 675
 676 void
 677 Lang::String::show( std::ostream & os ) const
 678 {
 679         os << val_.getPtr( ) ;
 680 }
 681
 682
 683 Lang::Continuation::Continuation( const Kernel::ContRef & cont )
 684         : cont_( cont )
 685 { }
 686
 687 Lang::Continuation::~Continuation( )
 688 { }
 689
 690 RefCountPtr< const Lang::Class > Lang::Continuation::TypeID( new Lang::SystemFinalClass( strrefdup( "Backtrace" ) ) );
 691 TYPEINFOIMPL( Continuation );
 692
 693 Kernel::VariableHandle
 694 Lang::Continuation::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 695 {
 696         if( strcmp( fieldID, "up" ) == 0 )
 697                 {
 698                         Kernel::ContRef res = cont_->up( );
 699                         if( res == NullPtr< Kernel::Continuation >( ) )
 700                                 {
 701                                         throw Exceptions::MiscellaneousRequirement( "The top continuation has no parent." );
 702                                 }
 703                         return Helpers::newValHandle( new Lang::Continuation( res ) );
 704                 }
 705         else if( strcmp( fieldID, "top?" ) == 0 )
 706                 {
 707                         Kernel::ContRef res = cont_->up( );
 708                         return ( res == NullPtr< Kernel::Continuation >( ) ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
 709                 }
 710         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 711 }
 712
 713 void
 714 Lang::Continuation::show( std::ostream & os ) const
 715 {
 716         os << "( backtrace to use in error messages )" ;
 717 }
 718
 719 void
 720 Lang::Continuation::gcMark( Kernel::GCMarkedSet & marked )
 721 {
 722         cont_->gcMark( marked );
 723 }
 724
 725
 726 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 )
 727         : loc_( loc ), kind_( kind ), source_( source ), details_( details ), message_( message ), cont_( cont ), exitCode_( exitCode )
 728 { }
 729
 730 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 )
 731         : loc_( cont->traceLoc( ) ), kind_( kind ), source_( source ), details_( details ), message_( message ), cont_( cont ), exitCode_( exitCode )
 732 { }
 733
 734 Lang::Exception::~Exception( )
 735 { }
 736
 737 RefCountPtr< const Lang::Class > Lang::Exception::TypeID( new Lang::SystemFinalClass( strrefdup( "Exception" ) ) );
 738 TYPEINFOIMPL( Exception );
 739
 740 Kernel::VariableHandle
 741 Lang::Exception::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 742 {
 743         if( strcmp( fieldID, "kind" ) == 0 )
 744                 {
 745                         return Kernel::VariableHandle( new Kernel::Variable( kind_ ) );
 746                 }
 747         else if( strcmp( fieldID, "source" ) == 0 )
 748                 {
 749                         return Kernel::VariableHandle( new Kernel::Variable( source_ ) );
 750                 }
 751         else if( strcmp( fieldID, "details" ) == 0 )
 752                 {
 753                         return Kernel::VariableHandle( new Kernel::Variable( details_ ) );
 754                 }
 755         else if( strcmp( fieldID, "backtrace" ) == 0 )
 756                 {
 757                         return Helpers::newValHandle( new Lang::Continuation( cont_ ) );
 758                 }
 759         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 760 }
 761
 762 void
 763 Lang::Exception::show( std::ostream & os ) const
 764 {
 765         os << message_ ;
 766 }
 767
 768 void
 769 Lang::Exception::gcMark( Kernel::GCMarkedSet & marked )
 770 {
 771         const_cast< Lang::Value * >( details_.getPtr( ) )->gcMark( marked );
 772         const_cast< Kernel::Continuation * >( cont_.getPtr( ) )->gcMark( marked );
 773 }
 774
 775
 776 Lang::FloatPair::FloatPair( const Concrete::UnitFloatPair & orig )
 777         : x_( orig.x_ ), y_( orig.y_ )
 778 { }
 779
 780
 781 DISPATCHIMPL( FloatPair );
 782
 783 Kernel::VariableHandle
 784 Lang::FloatPair::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 785 {
 786         if( strcmp( fieldID, "x" ) == 0 )
 787                 {
 788                         return Helpers::newValHandle( new Lang::Float( x_ ) );
 789                 }
 790         if( strcmp( fieldID, "y" ) == 0 )
 791                 {
 792                         return Helpers::newValHandle( new Lang::Float( y_ ) );
 793                 }
 794         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 795 }
 796
 797 RefCountPtr< const Lang::Class > Lang::FloatPair::TypeID( new Lang::SystemFinalClass( strrefdup( "FloatPair" ) ) );
 798 TYPEINFOIMPL( FloatPair );
 799
 800 RefCountPtr< const Lang::FloatPair >
 801 Lang::FloatPair::transformed( const Lang::Transform2D & tf ) const
 802 {
 803         return RefCountPtr< const Lang::FloatPair >
 804                 ( new Lang::FloatPair( tf.xx_ * x_ + tf.xy_ * y_, tf.yx_ * x_ + tf.yy_ * y_ ) );
 805 }
 806
 807 void
 808 Lang::FloatPair::show( std::ostream & os ) const
 809 {
 810         os << "( " << x_ << ", " << y_ << " )" ;
 811 }
 812
 813 Lang::FloatTriple::FloatTriple( const Concrete::UnitFloatTriple & orig )
 814         : x_( orig.x_ ), y_( orig.y_ ), z_( orig.z_ )
 815 { }
 816
 817 DISPATCHIMPL( FloatTriple );
 818
 819 Kernel::VariableHandle
 820 Lang::FloatTriple::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 821 {
 822         if( strcmp( fieldID, "x" ) == 0 )
 823                 {
 824                         return Helpers::newValHandle( new Lang::Float( x_ ) );
 825                 }
 826         if( strcmp( fieldID, "y" ) == 0 )
 827                 {
 828                         return Helpers::newValHandle( new Lang::Float( y_ ) );
 829                 }
 830         if( strcmp( fieldID, "z" ) == 0 )
 831                 {
 832                         return Helpers::newValHandle( new Lang::Float( z_ ) );
 833                 }
 834         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 835 }
 836
 837 RefCountPtr< const Lang::Class > Lang::FloatTriple::TypeID( new Lang::SystemFinalClass( strrefdup( "FloatTriple" ) ) );
 838 TYPEINFOIMPL( FloatTriple );
 839
 840 RefCountPtr< const Lang::FloatTriple >
 841 Lang::FloatTriple::transformed( const Lang::Transform3D & tf ) const
 842 {
 843         return RefCountPtr< const Lang::FloatTriple >
 844                 ( new Lang::FloatTriple( tf.xx_ * x_ + tf.xy_ * y_ + tf.xz_ * z_,
 845                                                                                                                  tf.yx_ * x_ + tf.yy_ * y_ + tf.yz_ * z_,
 846                                                                                                                  tf.zx_ * x_ + tf.zy_ * y_ + tf.zz_ * z_ ) );
 847 }
 848
 849 void
 850 Lang::FloatTriple::show( std::ostream & os ) const
 851 {
 852         os << "( " << x_ << ", " << y_ << ", " << z_ << " )" ;
 853 }
 854
 855
 856 Lang::Coords2D::Coords2D( const Lang::Coords2D & orig )
 857         : x_( orig.x_ ), y_( orig.y_ )
 858 { }
 859
 860 Lang::Coords2D::Coords2D( const Lang::Length & x, const Lang::Length & y )
 861         : x_( x ), y_( y )
 862 { }
 863
 864 Lang::Coords2D::Coords2D( const Concrete::Length & x, const Concrete::Length & y )
 865         : x_( x ), y_( y )
 866 { }
 867
 868 DISPATCHIMPL( Coords2D );
 869
 870 Kernel::VariableHandle
 871 Lang::Coords2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 872 {
 873         if( strcmp( fieldID, "x" ) == 0 )
 874                 {
 875                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 876                 }
 877         if( strcmp( fieldID, "y" ) == 0 )
 878                 {
 879                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 880                 }
 881         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 882 }
 883
 884 Lang::Coords2D *
 885 Lang::Coords2D::transformedPtr( const Lang::Transform2D & tf ) const
 886 {
 887         Concrete::Length tmpx = x_.get( );
 888         Concrete::Length tmpy = y_.get( );
 889         return new Lang::Coords2D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xt_, tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yt_ );
 890 }
 891
 892 RefCountPtr< const Lang::Geometric2D >
 893 Lang::Coords2D::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
 894 {
 895         return RefCountPtr< const Lang::Geometric2D >( transformedPtr( tf ) );
 896 }
 897
 898 RefCountPtr< const Lang::Geometric3D >
 899 Lang::Coords2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 900 {
 901         return RefCountPtr< const Lang::Coords3D >( new Lang::Coords3D( x_, y_, Lang::Length( Concrete::Length( 0 ) ) ) );
 902 }
 903
 904 RefCountPtr< const Lang::Class > Lang::Coords2D::TypeID( new Lang::SystemFinalClass( strrefdup( "Coords2D" ) ) );
 905 TYPEINFOIMPL( Coords2D );
 906
 907 void
 908 Lang::Coords2D::show( std::ostream & os ) const
 909 {
 910         os << "( " << x_ << ", " << y_ << " )" ;
 911 }
 912
 913 std::ostream &
 914 Lang::operator << ( std::ostream & os, const Lang::Coords2D & self )
 915 {
 916         os << "( " << self.x_ << ", " << self.y_ << " )" ;
 917         return os;
 918 }
 919
 920
 921 Lang::CornerCoords2D::CornerCoords2D( const Lang::Length & x, const Lang::Length & y, double a )
 922         : Lang::Coords2D( x, y ), a_( a )
 923 { }
 924
 925 Lang::CornerCoords2D::CornerCoords2D( const Concrete::Length & x, const Concrete::Length & y, double a )
 926         : Lang::Coords2D( x, y ), a_( a )
 927 { }
 928
 929 RefCountPtr< const Lang::Class > Lang::CornerCoords2D::TypeID( new Lang::SystemFinalClass( strrefdup( "CornerCoords2D" ) ) );
 930 DISPATCHIMPL( CornerCoords2D );
 931
 932 Kernel::VariableHandle
 933 Lang::CornerCoords2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 934 {
 935         if( strcmp( fieldID, "x" ) == 0 )
 936                 {
 937                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 938                 }
 939         if( strcmp( fieldID, "y" ) == 0 )
 940                 {
 941                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 942                 }
 943         if( strcmp( fieldID, "a" ) == 0 )
 944                 {
 945                         return Helpers::newValHandle( new Lang::Float( a_ ) );
 946                 }
 947         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
 948 }
 949
 950 Lang::CornerCoords2D *
 951 Lang::CornerCoords2D::transformedPtr( const Lang::Transform2D & tf ) const
 952 {
 953         Concrete::Length tmpx = x_.get( );
 954         Concrete::Length tmpy = y_.get( );
 955         return new Lang::CornerCoords2D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xt_, tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yt_, a_ );
 956 }
 957
 958 RefCountPtr< const Lang::Geometric2D >
 959 Lang::CornerCoords2D::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
 960 {
 961         return RefCountPtr< const Lang::Geometric2D >( transformedPtr( tf ) );
 962 }
 963
 964 RefCountPtr< const Lang::Geometric3D >
 965 Lang::CornerCoords2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
 966 {
 967         throw Exceptions::MiscellaneousRequirement( "Corner coordinates cannot move into 3D space." );
 968 }
 969
 970 TYPEINFOIMPL( CornerCoords2D );
 971
 972
 973 Lang::Coords3D::Coords3D( const Lang::Coords3D & orig )
 974         : x_( orig.x_ ), y_( orig.y_ ), z_( orig.z_ )
 975 { }
 976
 977 Lang::Coords3D::Coords3D( const Lang::Length & x, const Lang::Length & y, const Lang::Length & z )
 978         : x_( x ), y_( y ), z_( z )
 979 { }
 980
 981 Lang::Coords3D::Coords3D( const Concrete::Length & x, const Concrete::Length & y, const Concrete::Length & z )
 982         : x_( x ), y_( y ), z_( z )
 983 { }
 984
 985 DISPATCHIMPL( Coords3D );
 986
 987 Kernel::VariableHandle
 988 Lang::Coords3D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
 989 {
 990         if( strcmp( fieldID, "x" ) == 0 )
 991                 {
 992                         return Helpers::newValHandle( new Lang::Length( x_ ) );
 993                 }
 994         if( strcmp( fieldID, "y" ) == 0 )
 995                 {
 996                         return Helpers::newValHandle( new Lang::Length( y_ ) );
 997                 }
 998         if( strcmp( fieldID, "z" ) == 0 )
 999                 {
1000                         return Helpers::newValHandle( new Lang::Length( z_ ) );
1001                 }
1002         throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
1003 }
1004
1005 Lang::Coords3D *
1006 Lang::Coords3D::transformedPtr( const Lang::Transform3D & tf ) const
1007 {
1008         Concrete::Length tmpx = x_.get( );
1009         Concrete::Length tmpy = y_.get( );
1010         Concrete::Length tmpz = z_.get( );
1011         return new Lang::Coords3D( tf.xx_ * tmpx + tf.xy_ * tmpy + tf.xz_ * tmpz + tf.xt_,
1012                                                                                                                  tf.yx_ * tmpx + tf.yy_ * tmpy + tf.yz_ * tmpz + tf.yt_,
1013                                                                                                                  tf.zx_ * tmpx + tf.zy_ * tmpy + tf.zz_ * tmpz + tf.zt_ );
1014 }
1015
1016 RefCountPtr< const Lang::Geometric3D >
1017 Lang::Coords3D::transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const
1018 {
1019         return RefCountPtr< const Lang::Geometric3D >( transformedPtr( tf ) );
1020 }
1021
1022 RefCountPtr< const Lang::Coords2D >
1023 Lang::Coords3D::make2D( Concrete::Length eyez ) const
1024 {
1025         if( eyez < Concrete::HUGE_LENGTH )
1026                 {
1027                         return RefCountPtr< const Lang::Coords2D >( new Lang::Coords2D( x_.get( ) * ( eyez / ( eyez - z_.get( ) ) ),
1028                                                                                                                                                                                                                                                                                         y_.get( ) * ( eyez / ( eyez - z_.get( ) ) ) ) );
1029                 }
1030         return RefCountPtr< const Lang::Coords2D >( new Lang::Coords2D( x_.get( ),
1031                                                                                                                                                                                                                                                                         y_.get( ) ) );
1032 }
1033
1034
1035 RefCountPtr< const Lang::Geometric2D >
1036 Lang::Coords3D::to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const
1037 {
1038         return make2D( dyn->getEyeZ( ) );
1039 }
1040
1041 RefCountPtr< const Lang::Class > Lang::Coords3D::TypeID( new Lang::SystemFinalClass( strrefdup( "Coords3D" ) ) );
1042 TYPEINFOIMPL( Coords3D );
1043
1044 void
1045 Lang::Coords3D::show( std::ostream & os ) const
1046 {
1047         os << "( " << x_ << ", " << y_ << ", " << z_ << " )" ;
1048 }
1049
1050 std::ostream &
1051 Lang::operator << ( std::ostream & os, const Lang::Coords3D & self )
1052 {
1053         os << "( " << self.x_ << ", " << self.y_ << ", " << self.z_ << " )" ;
1054         return os;
1055 }
1056
1057
1058 namespace Shapes
1059 {
1060         namespace Kernel
1061         {
1062                 class StringMethod_select_cont : public Kernel::Continuation
1063                 {
1064                         RefCountPtr< const Lang::String > self_;
1065                         bool UTF8select_;
1066                         Kernel::ContRef cont_;
1067                 public:
1068                         StringMethod_select_cont( const RefCountPtr< const Lang::String > & self, bool UTF8select, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1069                                 : Kernel::Continuation( traceLoc ), self_( self ), UTF8select_( UTF8select ), cont_( cont )
1070                         { }
1071                         virtual ~StringMethod_select_cont( ) { }
1072                         virtual void takeValue( const RefCountPtr< const Lang::Value > & posUntyped, Kernel::EvalState * evalState, bool dummy ) const
1073                         {
1074                                 RefCountPtr< const Lang::SingleList > pos = posUntyped.down_cast< const Lang::SingleList >( );
1075                                 if( pos == NullPtr< const Lang::SingleList >( ) )
1076                                         throw Exceptions::InternalError( "StringMethod_select_cont::takeValue did not get a SingleList value." );
1077
1078                                 Lang::Integer::ValueType posEnd = UTF8select_ ? self_->UTF8count( ) : self_->bytecount_;
1079
1080                                 typedef std::vector< Lang::Integer::ValueType > PosVecType;
1081                                 PosVecType posTyped;
1082
1083                                 RefCountPtr< const Lang::SingleList > src = pos;
1084                                 while( ! src->isNull( ) )
1085                                         {
1086                                                 try
1087                                                         {
1088                                                                 typedef const Lang::SingleListPair ArgType;
1089                                                                 RefCountPtr< ArgType > p = Helpers::try_cast_CoreArgument< ArgType >( src );
1090                                                                 posTyped.push_back( p->car_->getVal< const Lang::Integer >( traceLoc_ )->val_ );
1091                                                                 src = p->cdr_;
1092                                                                 continue;
1093                                                         }
1094                                                 catch( const NonLocalExit::NotThisType & ball )
1095                                                         {
1096                                                                 /* Wrong type; never mind!.. but see below!
1097                                                                  */
1098                                                         }
1099                                                 try
1100                                                         {
1101                                                                 typedef const Lang::SingleListRange< const Lang::Integer > ArgType;
1102                                                                 RefCountPtr< ArgType > p = Helpers::try_cast_CoreArgument< ArgType >( src );
1103                                                                 p->expand( & posTyped );
1104                                                                 break;
1105                                                         }
1106                                                 catch( const NonLocalExit::NotThisType & ball )
1107                                                         {
1108                                                                 /* Wrong type; never mind!.. but see below!
1109                                                                  */
1110                                                         }
1111                                                 {
1112                                                         std::ostringstream msg;
1113                                                         msg << "When selecting bytes/characters in a string, all positions must be of type " << Lang::Integer::staticTypeName( ) << "." ;
1114                                                         throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
1115                                                 }
1116                                         }
1117
1118                                 for( PosVecType::const_iterator i = posTyped.begin( ); i != posTyped.end( ); ++i )
1119                                         {
1120                                                 if( *i < 0 )
1121                                                         {
1122                                                                 throw Exceptions::OutOfRange( "A negative position was encountered." );
1123                                                         }
1124                                                 if( *i >= posEnd )
1125                                                         {
1126                                                                 throw Exceptions::OutOfRange( "A position beyond the end of the string was encountered." );
1127                                                         }
1128                                         }
1129
1130                                 RefCountPtr< const char > resMem = RefCountPtr< const char >( NullPtr< const char >( ) );
1131                                 size_t resSize;
1132
1133                                 if( UTF8select_ )
1134                                         {
1135                                                 std::vector< Kernel::UnicodeCodePoint > selfChars;
1136                                                 selfChars.reserve( posEnd );
1137                                                 /* Compare String::UTF8count! */
1138                                                 {
1139                                                         Kernel::UnicodeCodePoint c;
1140                                                         const char * src = self_->val_.getPtr( );
1141                                                         const char * end = src + self_->bytecount_;
1142
1143                                                         while( *src > 0 )
1144                                                                 {
1145                                                                 ASCII:
1146                                                                         size_t avail = 1;
1147                                                                         c.decode_UTF8( & src, & avail );
1148                                                                         selfChars.push_back( c );
1149                                                                 }
1150
1151                                                         while( *src != 0 && src < end )
1152                                                                 {
1153                                                                         if( *src > 0 )
1154                                                                                 {
1155                                                                                         goto ASCII;
1156                                                                                 }
1157                                                                         else
1158                                                                                 {
1159                                                                                         switch( 0xF0 & *src )
1160                                                                                                 {
1161                                                                                                 case 0xE0:
1162                                                                                                         {
1163                                                                                                                 size_t avail = 3;
1164                                                                                                                 c.decode_UTF8( & src, & avail );
1165                                                                                                                 selfChars.push_back( c );
1166                                                                                                         }
1167                                                                                                         break;
1168                                                                                                 case 0xF0:
1169                                                                                                         {
1170                                                                                                                 size_t avail = 4;
1171                                                                                                                 c.decode_UTF8( & src, & avail );
1172                                                                                                                 selfChars.push_back( c );
1173                                                                                                         }
1174                                                                                                         break;
1175                                                                                                 default:
1176                                                                                                         {
1177                                                                                                                 size_t avail = 2;
1178                                                                                                                 c.decode_UTF8( & src, & avail );
1179                                                                                                                 selfChars.push_back( c );
1180                                                                                                         }
1181                                                                                                         break;
1182                                                                                                 }
1183                                                                                 }
1184                                                                 }
1185                                                         if( *src != 0 || src != end )
1186                                                                 {
1187                                                                         throw Exceptions::InternalError( "The string is not valid UTF-8, but this should have been detected when the characters were counted." );
1188                                                                 }
1189                                                 }
1190
1191                                                 std::ostringstream dst;
1192                                                 const size_t bufSize = 10;
1193                                                 char buf[ bufSize ];
1194                                                 for( PosVecType::const_iterator i = posTyped.begin( ); i != posTyped.end( ); ++i )
1195                                                         {
1196                                                                 char * tmpBuf = buf;
1197                                                                 size_t outAvail = bufSize;
1198                                                                 selfChars[ *i ].encode_UTF8( & tmpBuf, & outAvail );
1199                                                                 *tmpBuf = '\0';
1200                                                                 dst << buf;
1201                                                         }
1202                                                 resMem = strrefdup( dst );
1203                                                 resSize = dst.str( ).size( );
1204                                         }
1205                                 else
1206                                         {
1207                                                 resSize = posEnd;
1208                                                 char * dst = new char[ resSize + 1 ];
1209                                                 resMem = RefCountPtr< const char >( dst );
1210                                                 const char * srcBegin = self_->val_.getPtr( );
1211                                                 for( PosVecType::const_iterator i = posTyped.begin( ); i != posTyped.end( ); ++i, ++dst )
1212                                                         {
1213                                                                 *dst = *( srcBegin + *i );
1214                                                         }
1215                                                 *dst = '\0';
1216                                         }
1217
1218                                 evalState->cont_ = cont_;
1219                                 cont_->takeValue( RefCountPtr< const Lang::String >( new Lang::String( resMem, resSize ) ), evalState );
1220                         }
1221                         virtual Kernel::ContRef up( ) const
1222                         {
1223                                 return cont_;
1224                         }
1225                         virtual RefCountPtr< const char > description( ) const
1226                         {
1227                                 return strrefdup( "Select bytes/characters from String, after forcing positions." );
1228                         }
1229                         virtual void gcMark( Kernel::GCMarkedSet & marked )
1230                         {
1231                                 const_cast< Lang::String * >( self_.getPtr( ) )->gcMark( marked );
1232                                 cont_->gcMark( marked );
1233                         }
1234                 };
1235
1236                 class StringMethod_select_span_cont : public Kernel::Continuation
1237                 {
1238                         RefCountPtr< const Lang::String > self_;
1239                         bool UTF8select_;
1240                         Kernel::ContRef cont_;
1241                 public:
1242                         StringMethod_select_span_cont( const RefCountPtr< const Lang::String > & self, bool UTF8select, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1243                                 : Kernel::Continuation( traceLoc ), self_( self ), UTF8select_( UTF8select ), cont_( cont )
1244                         { }
1245                         virtual ~StringMethod_select_span_cont( ) { }
1246                         virtual void takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
1247                         {
1248                                 typedef const Lang::SingleList ArgType;
1249                                 RefCountPtr< ArgType > pos( Helpers::down_cast_ContinuationArgument< ArgType >( val, this ) );
1250
1251                                 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( Kernel::ContRef( new Kernel::StringMethod_select_cont( self_, UTF8select_, cont_, traceLoc_ ) ), traceLoc_ ) );
1252                                 Kernel::ContRef cont = evalState->cont_;
1253                                 cont->takeValue( pos, evalState );
1254                         }
1255                         virtual Kernel::ContRef up( ) const
1256                         {
1257                                 return cont_;
1258                         }
1259                         virtual RefCountPtr< const char > description( ) const
1260                         {
1261                                 return strrefdup( "Select bytes/characters from String, expand span." );
1262                         }
1263                         virtual void gcMark( Kernel::GCMarkedSet & marked )
1264                         {
1265                                 const_cast< Lang::String * >( self_.getPtr( ) )->gcMark( marked );
1266                                 cont_->gcMark( marked );
1267                         }
1268                 };
1269
1270         }
1271 }
1272
1273
1274 Lang::StringMethod_byteselect::StringMethod_byteselect( RefCountPtr< const Lang::String > self, const Ast::FileID * fullMethodID )
1275         : Lang::MethodBase< class_type >( self, fullMethodID, false, true )
1276 {
1277         formals_->appendEvaluatedCoreFormal( "pos", Kernel::THE_SLOT_VARIABLE );
1278 }
1279
1280 Lang::StringMethod_byteselect::~StringMethod_byteselect( )
1281 { }
1282
1283 void
1284 Lang::StringMethod_byteselect::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1285 {
1286         args.applyDefaults( callLoc );
1287
1288         size_t argsi = 0;
1289         try
1290                 {
1291                         typedef const Lang::SingleList ArgType;
1292                         RefCountPtr< ArgType > pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
1293
1294                         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( Kernel::ContRef( new Kernel::StringMethod_select_cont( self_, false, evalState->cont_, callLoc ) ), callLoc ) );
1295                         Kernel::ContRef cont = evalState->cont_;
1296                         cont->takeValue( pos, evalState );
1297                         return;
1298                 }
1299         catch( const NonLocalExit::NotThisType & ball )
1300                 {
1301                         /* Wrong type; never mind!.. but see below!
1302                          */
1303                 }
1304
1305         try
1306                 {
1307                         typedef const Lang::Span ArgType;
1308                         RefCountPtr< ArgType > pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
1309
1310                         evalState->cont_ = Kernel::ContRef( new Kernel::StringMethod_select_span_cont( self_, false, evalState->cont_, callLoc ) );
1311                         pos->Lang::Function::call( evalState, RefCountPtr< const Lang::Value >( new Lang::Integer( self_->bytecount_ - 1 ) ), callLoc );
1312                         return;
1313                 }
1314         catch( const NonLocalExit::NotThisType & ball )
1315                 {
1316                         /* Wrong type; never mind!.. but see below!
1317                          */
1318                 }
1319
1320         try
1321                 {
1322                         typedef const Lang::Integer ArgType;
1323                         ArgType::ValueType pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) )->val_;
1324                         if( pos < 0 )
1325                                 {
1326                                         throw Exceptions::CoreOutOfRange( coreLoc_, args, argsi, "The position is negative." );
1327                                 }
1328                         size_t upos = pos;
1329                         if( upos >= self_->bytecount_ )
1330                                 {
1331                                         throw Exceptions::CoreOutOfRange( coreLoc_, args, argsi, "The position is beyond the end of the string." );
1332                                 }
1333                         Kernel::ContRef cont = evalState->cont_;
1334                         cont->takeValue( Kernel::ValueRef( new Lang::Integer( *reinterpret_cast< const unsigned char * >( self_->val_.getPtr( ) + upos ) ) ),
1335                                                                                          evalState );
1336                         return;
1337                 }
1338         catch( const NonLocalExit::NotThisType & ball )
1339                 {
1340                         /* Wrong type; never mind!.. but see below!
1341                          */
1342                 }
1343
1344         throw Exceptions::CoreTypeMismatch( callLoc, coreLoc_, args, argsi, Helpers::typeSetString( Lang::SingleList::staticTypeName( ), Lang::Span::staticTypeName( ) ) );
1345 }
1346
1347 Lang::StringMethod_UTF8select::StringMethod_UTF8select( RefCountPtr< const Lang::String > self, const Ast::FileID * fullMethodID )
1348         : Lang::MethodBase< class_type >( self, fullMethodID, false, true )
1349 {
1350         formals_->appendEvaluatedCoreFormal( "pos", Kernel::THE_SLOT_VARIABLE );
1351 }
1352
1353 Lang::StringMethod_UTF8select::~StringMethod_UTF8select( )
1354 { }
1355
1356 void
1357 Lang::StringMethod_UTF8select::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1358 {
1359         args.applyDefaults( callLoc );
1360
1361         size_t argsi = 0;
1362         try
1363                 {
1364                         typedef const Lang::SingleList ArgType;
1365                         RefCountPtr< ArgType > pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
1366
1367                         evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation( Kernel::ContRef( new Kernel::StringMethod_select_cont( self_, true, evalState->cont_, callLoc ) ), callLoc ) );
1368                         Kernel::ContRef cont = evalState->cont_;
1369                         cont->takeValue( pos, evalState );
1370                         return;
1371                 }
1372         catch( const NonLocalExit::NotThisType & ball )
1373                 {
1374                         /* Wrong type; never mind!.. but see below!
1375                          */
1376                 }
1377
1378         try
1379                 {
1380                         typedef const Lang::Span ArgType;
1381                         RefCountPtr< ArgType > pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
1382
1383                         evalState->cont_ = Kernel::ContRef( new Kernel::StringMethod_select_span_cont( self_, true, evalState->cont_, callLoc ) );
1384                         pos->Lang::Function::call( evalState, RefCountPtr< const Lang::Value >( new Lang::Integer( self_->UTF8count( ) - 1 ) ), callLoc );
1385                         return;
1386                 }
1387         catch( const NonLocalExit::NotThisType & ball )
1388                 {
1389                         /* Wrong type; never mind!.. but see below!
1390                          */
1391                 }
1392
1393         try
1394                 {
1395                         typedef const Lang::Integer ArgType;
1396                         ArgType::ValueType pos = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) )->val_;
1397                         if( pos < 0 )
1398                                 {
1399                                         throw Exceptions::CoreOutOfRange( coreLoc_, args, argsi, "The position is negative." );
1400                                 }
1401                         size_t upos = pos;
1402                         if( upos >= self_->UTF8count( ) )
1403                                 {
1404                                         throw Exceptions::CoreOutOfRange( coreLoc_, args, argsi, "The position is beyond the end of the string." );
1405                                 }
1406
1407                         /* Compare String::UTF8count ! */
1408
1409                         const char * src = self_->val_.getPtr( );
1410                         const char * end = src + self_->bytecount_;
1411
1412                         const char * ASCIIstart = src;
1413                         size_t count = 0;
1414                         if( count == upos )
1415                                 {
1416                                         goto done;
1417                                 }
1418                         while( *src > 0 )
1419                                 {
1420                                 ASCII:
1421                                         ++src;
1422                                 }
1423                         count += src - ASCIIstart;
1424                         if( count >= upos )
1425                                 {
1426                                         src -= ( count - upos );
1427                                         goto done;
1428                                 }
1429                         while( *src != 0 && src < end )
1430                                 {
1431                                         if( *src > 0 )
1432                                                 {
1433                                                         ASCIIstart = src;
1434                                                         goto ASCII;
1435                                                 }
1436                                         else
1437                                                 {
1438                                                         switch( 0xF0 & *src )
1439                                                                 {
1440                                                                 case 0xE0: src += 3; break;
1441                                                                 case 0xF0: src += 4; break;
1442                                                                 default:   src += 2; break;
1443                                                                 }
1444                                                 }
1445                                         ++count;
1446                                         if( count == upos )
1447                                                 {
1448                                                         goto done;
1449                                                 }
1450                                 }
1451                         if( *src != 0 || src != end )
1452                                 {
1453                                         throw Exceptions::InternalError( "Failed to located character at given position in string." );
1454                                 }
1455
1456                 done:
1457                         Kernel::UnicodeCodePoint c;
1458                         c.decode_UTF8( src );
1459                         Kernel::ContRef cont = evalState->cont_;
1460                         cont->takeValue( Kernel::ValueRef( new Lang::Character( c ) ),
1461                                                                                          evalState );
1462                         return;
1463                 }
1464         catch( const NonLocalExit::NotThisType & ball )
1465                 {
1466                         /* Wrong type; never mind!.. but see below!
1467                          */
1468                 }
1469
1470         throw Exceptions::CoreTypeMismatch( callLoc, coreLoc_, args, argsi, Helpers::typeSetString( Lang::SingleList::staticTypeName( ), Lang::Span::staticTypeName( ) ) );
1471 }