source/shapescore.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 "Shapes_Helpers_decls.h"
  22
  23 #include "shapescore.h"
  24 #include "globals.h"
  25 #include "shapesexceptions.h"
  26 #include "astexpr.h"
  27 #include "astfun.h"
  28 #include "consts.h"
  29 #include "simplepdfi.h"
  30
  31 #include <iostream>
  32 #include <sstream>
  33 #include <fstream>
  34 #include <vector>
  35 #include <stdio.h>
  36
  37 using namespace Shapes;
  38
  39
  40 RefCountPtr< const Lang::ElementaryPath2D >
  41 Helpers::elementaryPathCast2D( const char * title, Kernel::Arguments & args, size_t argNo, const Ast::SourceLocation & callLoc )
  42 {
  43         RefCountPtr< const Lang::Value > ptr = args.getValue( argNo );
  44         typedef const Lang::ElementaryPath2D ArgType;
  45         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
  46         if( res != NullPtr< ArgType >( ) )
  47                 {
  48                         return res;
  49                 }
  50
  51         typedef const Lang::CompositePath2D ArgType2;
  52         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
  53         if( res2 == 0 )
  54                 {
  55                         throw Exceptions::CoreTypeMismatch( callLoc, title, args, argNo, ArgType::staticTypeName( ) );
  56                 }
  57
  58         return res2->getElementaryPath( );
  59 }
  60
  61 RefCountPtr< const Lang::ElementaryPath2D >
  62 Helpers::elementaryPathCast2D( const RefCountPtr< const Lang::Value > & ptr, const Kernel::Continuation * loc )
  63 {
  64         typedef const Lang::ElementaryPath2D ArgType;
  65         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
  66         if( res != NullPtr< ArgType >( ) )
  67                 {
  68                         return res;
  69                 }
  70
  71         typedef const Lang::CompositePath2D ArgType2;
  72         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
  73         if( res2 == 0 )
  74                 {
  75                         throw Exceptions::ContinuationTypeMismatch( loc, ptr->getTypeName( ), ArgType::staticTypeName( ) );
  76                 }
  77
  78         return res2->getElementaryPath( );
  79 }
  80
  81 RefCountPtr< const Lang::ElementaryPath2D >
  82 Helpers::elementaryPathTry2D( const RefCountPtr< const Lang::Value > & ptr )
  83 {
  84         typedef const Lang::ElementaryPath2D ArgType;
  85         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
  86         if( res != NullPtr< ArgType >( ) )
  87                 {
  88                         return res;
  89                 }
  90
  91         typedef const Lang::CompositePath2D ArgType2;
  92         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
  93         if( res2 == 0 )
  94                 {
  95                         throw NonLocalExit::NotThisType( );
  96                 }
  97
  98         return res2->getElementaryPath( );
  99 }
 100
 101
 102 Concrete::SplineTime
 103 Helpers::pathTimeCast( const char * title, const RefCountPtr< const Lang::ElementaryPath2D > & pRef, Kernel::Arguments & args, size_t argNo, const Ast::SourceLocation & callLoc )
 104 {
 105         const Lang::ElementaryPath2D * p = pRef.getPtr( );
 106         const Lang::Value * tPtr = args.getValue( argNo ).getPtr( );
 107         typedef const Lang::Float ArgType;
 108         ArgType * res = dynamic_cast< ArgType * >( tPtr );
 109         if( res != 0 )
 110                 {
 111                         return Concrete::Time( res->val_ );
 112                 }
 113
 114         typedef const Lang::Length ArgType2;
 115         ArgType2 * res2 = dynamic_cast< ArgType2 * >( tPtr );
 116         if( res2 == 0 )
 117                 {
 118                         throw Exceptions::CoreTypeMismatch( callLoc, title, args, argNo, typeSetString( ArgType::staticTypeName( ), ArgType::staticTypeName( ) ) );
 119                 }
 120
 121         return p->arcTime( res2->get( ) );
 122 }
 123
 124 Concrete::SplineTime
 125 Helpers::pathTimeCast( const Lang::ElementaryPath2D * p, const Lang::Value * tPtr, const Kernel::Continuation * loc )
 126 {
 127         typedef const Lang::Float ArgType;
 128         ArgType * res = dynamic_cast< ArgType * >( tPtr );
 129         if( res != 0 )
 130                 {
 131                         return Concrete::Time( res->val_ );
 132                 }
 133
 134         typedef const Lang::Length ArgType2;
 135         ArgType2 * res2 = dynamic_cast< ArgType2 * >( tPtr );
 136         if( res2 == 0 )
 137                 {
 138                         throw Exceptions::ContinuationTypeMismatch( loc, tPtr->getTypeName( ), typeSetString( ArgType::staticTypeName( ), ArgType2::staticTypeName( ) ) );
 139                 }
 140
 141         return p->arcTime( res2->get( ) );
 142 }
 143
 144
 145 RefCountPtr< const Lang::ElementaryPath3D >
 146 Helpers::elementaryPathCast3D( const char * title, Kernel::Arguments & args, size_t argNo, const Ast::SourceLocation & callLoc )
 147 {
 148         RefCountPtr< const Lang::Value > ptr = args.getValue( argNo );
 149         typedef const Lang::ElementaryPath3D ArgType;
 150         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
 151         if( res != NullPtr< ArgType >( ) )
 152                 {
 153                         return res;
 154                 }
 155
 156         typedef const Lang::CompositePath3D ArgType2;
 157         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
 158         if( res2 == 0 )
 159                 {
 160                         throw Exceptions::CoreTypeMismatch( callLoc, title, args, argNo, ArgType::staticTypeName( ) );
 161                 }
 162
 163         return res2->getElementaryPath( );
 164 }
 165
 166 RefCountPtr< const Lang::ElementaryPath3D >
 167 Helpers::elementaryPathCast3D( const RefCountPtr< const Lang::Value > & ptr, const Kernel::Continuation * loc )
 168 {
 169         typedef const Lang::ElementaryPath3D ArgType;
 170         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
 171         if( res != NullPtr< ArgType >( ) )
 172                 {
 173                         return res;
 174                 }
 175
 176         typedef const Lang::CompositePath3D ArgType2;
 177         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
 178         if( res2 == 0 )
 179                 {
 180                         throw Exceptions::ContinuationTypeMismatch( loc, ptr->getTypeName( ), ArgType::staticTypeName( ) );
 181                 }
 182
 183         return res2->getElementaryPath( );
 184 }
 185
 186 RefCountPtr< const Lang::ElementaryPath3D >
 187 Helpers::elementaryPathTry3D( const RefCountPtr< const Lang::Value > & ptr )
 188 {
 189         typedef const Lang::ElementaryPath3D ArgType;
 190         RefCountPtr< ArgType > res = ptr.down_cast< ArgType >( );
 191         if( res != NullPtr< ArgType >( ) )
 192                 {
 193                         return res;
 194                 }
 195
 196         typedef const Lang::CompositePath3D ArgType2;
 197         ArgType2 * res2 = dynamic_cast< ArgType2 * >( ptr.getPtr( ) );
 198         if( res2 == 0 )
 199                 {
 200                         throw NonLocalExit::NotThisType( );
 201                 }
 202
 203         return res2->getElementaryPath( );
 204 }
 205
 206
 207 Concrete::SplineTime
 208 Helpers::pathTimeCast( const char * title, const RefCountPtr< const Lang::ElementaryPath3D > & pRef, Kernel::Arguments & args, size_t argNo, const Ast::SourceLocation & callLoc )
 209 {
 210         const Lang::ElementaryPath3D * p = pRef.getPtr( );
 211         const Lang::Value * tPtr = args.getValue( argNo ).getPtr( );
 212         typedef const Lang::Float ArgType;
 213         ArgType * res = dynamic_cast< ArgType * >( tPtr );
 214         if( res != 0 )
 215                 {
 216                         return Concrete::Time( res->val_ );
 217                 }
 218
 219         typedef const Lang::Length ArgType2;
 220         ArgType2 * res2 = dynamic_cast< ArgType2 * >( tPtr );
 221         if( res2 == 0 )
 222                 {
 223                         throw Exceptions::CoreTypeMismatch( callLoc, title, args, argNo, typeSetString( ArgType::staticTypeName( ), ArgType::staticTypeName( ) ) );
 224                 }
 225
 226         return p->arcTime( res2->get( ) );
 227 }
 228
 229 Concrete::SplineTime
 230 Helpers::pathTimeCast( const Lang::ElementaryPath3D * p, const Lang::Value * tPtr, const Kernel::Continuation * loc )
 231 {
 232         typedef const Lang::Float ArgType;
 233         ArgType * res = dynamic_cast< ArgType * >( tPtr );
 234         if( res != 0 )
 235                 {
 236                         return Concrete::Time( res->val_ );
 237                 }
 238
 239         typedef const Lang::Length ArgType2;
 240         ArgType2 * res2 = dynamic_cast< ArgType2 * >( tPtr );
 241         if( res2 == 0 )
 242                 {
 243                         throw Exceptions::ContinuationTypeMismatch( loc, tPtr->getTypeName( ), typeSetString( ArgType::staticTypeName( ), ArgType2::staticTypeName( ) ) );
 244                 }
 245
 246         return p->arcTime( res2->get( ) );
 247 }
 248
 249
 250 RefCountPtr< const char >
 251 Helpers::typeSetString( RefCountPtr< const char > type1, RefCountPtr< const char > type2 )
 252 {
 253         std::list< RefCountPtr< const char > > types;
 254         types.push_back( type1 );
 255         types.push_back( type2 );
 256         return typeSetString( types );
 257 }
 258
 259 RefCountPtr< const char >
 260 Helpers::typeSetString( RefCountPtr< const char > type1, RefCountPtr< const char > type2, RefCountPtr< const char > type3 )
 261 {
 262         std::list< RefCountPtr< const char > > types;
 263         types.push_back( type1 );
 264         types.push_back( type2 );
 265         types.push_back( type3 );
 266         return typeSetString( types );
 267 }
 268
 269 RefCountPtr< const char >
 270 Helpers::typeSetString( RefCountPtr< const char > type1, RefCountPtr< const char > type2, RefCountPtr< const char > type3, RefCountPtr< const char > type4 )
 271 {
 272         std::list< RefCountPtr< const char > > types;
 273         types.push_back( type1 );
 274         types.push_back( type2 );
 275         types.push_back( type3 );
 276         types.push_back( type4 );
 277         return typeSetString( types );
 278 }
 279
 280 RefCountPtr< const char >
 281 Helpers::typeSetString( RefCountPtr< const char > type1, RefCountPtr< const char > type2, RefCountPtr< const char > type3, RefCountPtr< const char > type4, RefCountPtr< const char > type5 )
 282 {
 283         std::list< RefCountPtr< const char > > types;
 284         types.push_back( type1 );
 285         types.push_back( type2 );
 286         types.push_back( type3 );
 287         types.push_back( type4 );
 288         types.push_back( type5 );
 289         return typeSetString( types );
 290 }
 291
 292 RefCountPtr< const char >
 293 Helpers::typeSetString( const std::list< RefCountPtr< const char > > types )
 294 {
 295         std::ostringstream oss;
 296         oss << "any of {" ;
 297         if( ! types.empty( ) )
 298                 {
 299                         typedef typeof types ListType;
 300                         ListType::const_iterator i = types.begin( );
 301                         oss << " " << *i ;
 302                         ++i;
 303                         for( ; i != types.end( ); ++i )
 304                                 {
 305                                         oss << ", " << *i ;
 306                                 }
 307                 }
 308         oss << " }" ;
 309         return strrefdup( oss );
 310 }
 311
 312 Lang::CoreFunction::CoreFunction( const char * title )
 313         : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) ), title_( title )
 314 { }
 315
 316 Lang::CoreFunction::CoreFunction( const char * title, Kernel::EvaluatedFormals * formals )
 317         : Lang::Function( formals ), title_( title )
 318 { }
 319
 320 void
 321 Lang::CoreFunction::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
 322 {
 323         /* Nothing to be done! */
 324 }
 325
 326 bool
 327 Lang::CoreFunction::isTransforming( ) const
 328 {
 329         return false;
 330 }
 331
 332 const char *
 333 Lang::CoreFunction::getTitle( ) const
 334 {
 335         return title_;
 336 }
 337
 338 void
 339 Lang::CoreFunction::show( std::ostream & os ) const
 340 {
 341         os << "< core function: " << title_ << " >" ;
 342 }