?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Example: Changed glyph-outline.shape for use with FontConfig.
[shapes.git] / source / functiontypes.cc
blob169c8855fe1a0fe1868ecf1abe25aae1c19b1d5f
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 "singlelistrange.h"
22
23 #include "shapestypes.h"
24 #include "shapesexceptions.h"
25 #include "astexpr.h"
26 #include "consts.h"
27 #include "angleselect.h"
28 #include "astvar.h"
29 #include "astclass.h"
30 #include "globals.h"
31 #include "continuations.h"
32 #include "methodbase.h"
33 #include "shapescore.h"
34 #include "check.h"
35
36 //#include "clapack.h"
37 //#include "cblas.h"
38 #include <gsl/gsl_matrix.h>
39 #include <gsl/gsl_linalg.h>
40 #include <gsl/gsl_blas.h>
41 #include <ctype.h>
42 #include <stack>
43 #include <algorithm>
44
45 #define CHOP_Ltol( x )\
46 if( fabs( x ) < Ltol )\
47 {\
48 x = 0;\
49 }\
50 else if( fabs( x - 1 ) < Ltol )\
51 {\
52 x = 1;\
53 }\
54 else if( fabs( x + 1 ) < Ltol )\
55 {\
56 x = -1;\
57 }
58
59 #define CHOP_ptol( x )\
60 if( x.abs( ) < ptol )\
61 {\
62 x = Concrete::ZERO_LENGTH;\
63 }
64
65 using namespace Shapes;
66 using namespace std;
67
68 void displayArray( std::ostream & os, const double * pr, size_t m, size_t n )
69 {
70 size_t r;
71 size_t c;
72 char buf[20];
73 for( r = 0; r < m; ++r )
74 {
75 for( c = 0; c < n; ++c )
76 {
77 sprintf( buf, "%14.5e", *( pr + ( r + c * m ) ) );
78 os << buf ;
79 }
80 os << std::endl ;
81 }
82 }
83
84 void displayArray( std::ostream & os, const gsl_matrix * m )
85 {
86 char buf[20];
87 for( size_t r = 0; r < m->size1; ++r )
88 {
89 for( size_t c = 0; c < m->size2; ++c )
90 {
91 sprintf( buf, "%14.5e", gsl_matrix_get( m, r, c ) );
92 os << buf ;
93 }
94 os << std::endl ;
95 }
96 }
97
98 namespace Shapes
99 {
100
101 namespace Lang
102 {
103
104 class Transform2DMethod_chop : public Lang::MethodBase< Lang::Transform2D >
105 {
106 public:
107 Transform2DMethod_chop( RefCountPtr< const Lang::Transform2D > _self, const Ast::FileID * fullMethodID );
108 virtual ~Transform2DMethod_chop( );
109 virtual void call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const;
110 static const char * staticFieldID( ) { return "chop"; }
111 };
112
113 class Transform3DMethod_chop : public Lang::MethodBase< Lang::Transform3D >
114 {
115 public:
116 Transform3DMethod_chop( RefCountPtr< const Lang::Transform3D > _self, const Ast::FileID * fullMethodID );
117 virtual ~Transform3DMethod_chop( );
118 virtual void call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const;
119 static const char * staticFieldID( ) { return "chop"; }
120 };
121
122 }
123 }
124
125 void
126 Transform2D_register_methods( Lang::SystemFinalClass * dstClass )
127 {
128 dstClass->registerMethod( new Kernel::MethodFactory< Lang::Transform2D, Lang::Transform2DMethod_chop >( ) );
129 }
130
131 RefCountPtr< const Lang::Class > Lang::Transform2D::TypeID( new Lang::SystemFinalClass( strrefdup( "Transform2D" ), Transform2D_register_methods ) );
132 TYPEINFOIMPL( Transform2D );
133
134 Lang::Transform2D::Transform2D( double xx, double yx, double xy, double yy, Concrete::Length xt, Concrete::Length yt )
135 : xx_( xx ), yx_( yx ), xy_( xy ), yy_( yy ), xt_( xt ), yt_( yt )
136 { }
137
138 Lang::Transform2D::Transform2D( const Lang::Transform2D & tf2, const Lang::Transform2D & tf1 )
139 : xx_( tf2.xx_ * tf1.xx_ + tf2.xy_ * tf1.yx_ ),
140 yx_( tf2.yx_ * tf1.xx_ + tf2.yy_ * tf1.yx_ ),
141 xy_( tf2.xx_ * tf1.xy_ + tf2.xy_ * tf1.yy_ ),
142 yy_( tf2.yx_ * tf1.xy_ + tf2.yy_ * tf1.yy_ ),
143 xt_( tf2.xx_ * tf1.xt_ + tf2.xy_ * tf1.yt_ + tf2.xt_ ),
144 yt_( tf2.yx_ * tf1.xt_ + tf2.yy_ * tf1.yt_ + tf2.yt_ )
145 { }
146
147 DISPATCHIMPL( Transform2D );
148
149 Lang::Transform2D::~Transform2D( )
150 { }
151
152 Kernel::VariableHandle
153 Lang::Transform2D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
154 {
155 const size_t N = 2;
156 if( strcmp( fieldID, "p" ) == 0 )
157 {
158 return Helpers::newValHandle( new Lang::Coords2D( xt_, yt_ ) );
159 }
160 if( strcmp( fieldID, "L" ) == 0 )
161 {
162 return Helpers::newValHandle( new Lang::Transform2D( xx_, yx_, xy_, yy_, 0, 0 ) );
163 }
164 if( strcmp( fieldID, "Lx" ) == 0 )
165 {
166 return Helpers::newValHandle( new Lang::FloatPair( xx_, yx_ ) );
167 }
168 if( strcmp( fieldID, "Ly" ) == 0 )
169 {
170 return Helpers::newValHandle( new Lang::FloatPair( xy_, yy_ ) );
171 }
172 if( strcmp( fieldID, "xL" ) == 0 )
173 {
174 return Helpers::newValHandle( new Lang::FloatPair( xx_, xy_ ) );
175 }
176 if( strcmp( fieldID, "yL" ) == 0 )
177 {
178 return Helpers::newValHandle( new Lang::FloatPair( yx_, yy_ ) );
179 }
180 if( strcmp( fieldID, "linear?" ) == 0 )
181 {
182 return ( xt_ == 0 && yt_ == 0 ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
183 }
184 if( strcmp( fieldID, "translation?" ) == 0 )
185 {
186 return isTranslation( ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
187 }
188 if( strcmp( fieldID, "special?" ) == 0 )
189 {
190 gsl_matrix * A = gsl_matrix_alloc( N, N );
191 gsl_permutation * perm = gsl_permutation_alloc( N );
192 int signum;
193 write_gsl_matrix( A );
194 gsl_linalg_LU_decomp( A, perm, & signum );
195 bool res = gsl_linalg_LU_det( A, signum ) > 0;
196 gsl_matrix_free( A );
197 gsl_permutation_free( perm );
198 return res ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
199 }
200 if( strcmp( fieldID, "Euclidean?" ) == 0 )
201 {
202 gsl_matrix * A = gsl_matrix_alloc( N, N );
203 gsl_vector * SVD_work = gsl_vector_alloc( N );
204 gsl_vector * sigma = gsl_vector_alloc( N );
205 gsl_matrix * V = gsl_matrix_alloc( N, N );
206 write_gsl_matrix( A );
207 gsl_linalg_SV_decomp( A, V, sigma, SVD_work );
208 const double tol = 1e-4;
209 bool res = 1 - tol < gsl_vector_get( sigma, N - 1 ) && gsl_vector_get( sigma, 0 ) < 1 + tol;
210 gsl_matrix_free( V );
211 gsl_vector_free( sigma );
212 gsl_vector_free( SVD_work );
213 gsl_matrix_free( A );
214 return res ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
215 }
216
217 return TypeID->getMethod( selfRef, fieldID ); /* This will throw if there is no such method. */
218 }
219
220 Lang::Transform2D *
221 Lang::Transform2D::clone( ) const
222 {
223 return new Transform2D( xx_, yx_,
224 xy_, yy_,
225 xt_, yt_ );
226 }
227
228 bool
229 Lang::Transform2D::isIdentity( ) const
230 {
231 return
232 xt_ == Concrete::ZERO_LENGTH && yt_ == Concrete::ZERO_LENGTH &&
233 xx_ == 1 && yy_ == 1 &&
234 xy_ == 0 && yx_ == 0;
235 }
236
237 bool
238 Lang::Transform2D::isTranslation( ) const
239 {
240 return
241 xx_ == 1 && yy_ == 1 &&
242 xy_ == 0 && yx_ == 0;
243 }
244
245 void
246 Lang::Transform2D::write_gsl_matrix( gsl_matrix * matrix_2_2 ) const
247 {
248 gsl_matrix_set( matrix_2_2, 0, 0, xx_ );
249 gsl_matrix_set( matrix_2_2, 1, 0, yx_ );
250 gsl_matrix_set( matrix_2_2, 0, 1, xy_ );
251 gsl_matrix_set( matrix_2_2, 1, 1, yy_ );
252 }
253
254 void
255 Lang::Transform2D::write_gsl_vector( gsl_vector * vec_2 ) const
256 {
257 gsl_vector_set( vec_2, 0, Concrete::Length::offtype( xt_ ) );
258 gsl_vector_set( vec_2, 1, Concrete::Length::offtype( yt_ ) );
259 }
260
261 void
262 Lang::Transform2D::shipout( std::ostream & os ) const
263 {
264 os << xx_ << " " << yx_ << " " << xy_ << " " << yy_ << " "
265 << Concrete::Length::offtype( xt_ ) << " " << Concrete::Length::offtype( yt_ ) ;
266 }
267
268 // to be used by text moveto commands
269 void
270 Lang::Transform2D::replaceBy( const Lang::Transform2D & newtf )
271 {
272 xx_ = newtf.xx_;
273 yx_ = newtf.yx_;
274 xy_ = newtf.xy_;
275 yy_ = newtf.yy_;
276 xt_ = newtf.xt_;
277 yt_ = newtf.yt_;
278 }
279
280 // to be used by text newline commands
281 void
282 Lang::Transform2D::prependShift( const Concrete::Coords2D & d )
283 {
284 // Think of d as tf1 when composing transforms.
285
286 xt_ += xx_ * d.x_ + xy_ * d.y_;
287 yt_ += yx_ * d.x_ + yy_ * d.y_;
288 }
289
290 // to be used by text painting commands
291 void
292 Lang::Transform2D::prependXShift( const Concrete::Length & dx )
293 {
294 // Think of d as tf1 when composing transforms.
295
296 xt_ += xx_ * dx;
297 yt_ += yx_ * dx;
298 }
299
300 void
301 Lang::Transform2D::show( std::ostream & os ) const
302 {
303 os << "[ ("
304 << xx_ << ", " << yx_ << ") ("
305 << xy_ << ", " << yy_ << ") ("
306 << Lang::Length( xt_ ) << ", " << Lang::Length( yt_ ) << ") ]" ;
307 }
308
309
310 void
311 Transform3D_register_methods( Lang::SystemFinalClass * dstClass )
312 {
313 dstClass->registerMethod( new Kernel::MethodFactory< Lang::Transform3D, Lang::Transform3DMethod_chop >( ) );
314 }
315
316 RefCountPtr< const Lang::Class > Lang::Transform3D::TypeID( new Lang::SystemFinalClass( strrefdup( "Transform3D" ), Transform3D_register_methods ) );
317 TYPEINFOIMPL( Transform3D );
318
319 Lang::Transform3D::Transform3D( double xx, double yx, double zx, double xy, double yy, double zy, double xz, double yz, double zz, Concrete::Length xt, Concrete::Length yt, Concrete::Length zt )
320 : planeNormalTransformData_( 0 ),
321 xx_( xx ), yx_( yx ), zx_( zx ), xy_( xy ), yy_( yy ), zy_( zy ), xz_( xz ), yz_( yz ), zz_( zz ), xt_( xt ), yt_( yt ), zt_( zt )
322 { }
323
324 Lang::Transform3D::Transform3D( const gsl_matrix * matrix_3_3, const gsl_vector * vec_3 )
325 : planeNormalTransformData_( 0 ),
326 xx_( gsl_matrix_get( matrix_3_3, 0, 0 ) ), yx_( gsl_matrix_get( matrix_3_3, 1, 0 ) ), zx_( gsl_matrix_get( matrix_3_3, 2, 0 ) ),
327 xy_( gsl_matrix_get( matrix_3_3, 0, 1 ) ), yy_( gsl_matrix_get( matrix_3_3, 1, 1 ) ), zy_( gsl_matrix_get( matrix_3_3, 2, 1 ) ),
328 xz_( gsl_matrix_get( matrix_3_3, 0, 2 ) ), yz_( gsl_matrix_get( matrix_3_3, 1, 2 ) ), zz_( gsl_matrix_get( matrix_3_3, 2, 2 ) ),
329 xt_( gsl_vector_get( vec_3, 0 ) ), yt_( gsl_vector_get( vec_3, 1 ) ), zt_( gsl_vector_get( vec_3, 2 ) )
330 { }
331
332
333
334 Lang::Transform3D::Transform3D( const Lang::Transform3D & tf2, const Lang::Transform3D & tf1 )
335 : planeNormalTransformData_( 0 ),
336 xx_( tf2.xx_ * tf1.xx_ + tf2.xy_ * tf1.yx_ + tf2.xz_ * tf1.zx_ ),
337 yx_( tf2.yx_ * tf1.xx_ + tf2.yy_ * tf1.yx_ + tf2.yz_ * tf1.zx_ ),
338 zx_( tf2.zx_ * tf1.xx_ + tf2.zy_ * tf1.yx_ + tf2.zz_ * tf1.zx_ ),
339 xy_( tf2.xx_ * tf1.xy_ + tf2.xy_ * tf1.yy_ + tf2.xz_ * tf1.zy_ ),
340 yy_( tf2.yx_ * tf1.xy_ + tf2.yy_ * tf1.yy_ + tf2.yz_ * tf1.zy_ ),
341 zy_( tf2.zx_ * tf1.xy_ + tf2.zy_ * tf1.yy_ + tf2.zz_ * tf1.zy_ ),
342 xz_( tf2.xx_ * tf1.xz_ + tf2.xy_ * tf1.yz_ + tf2.xz_ * tf1.zz_ ),
343 yz_( tf2.yx_ * tf1.xz_ + tf2.yy_ * tf1.yz_ + tf2.yz_ * tf1.zz_ ),
344 zz_( tf2.zx_ * tf1.xz_ + tf2.zy_ * tf1.yz_ + tf2.zz_ * tf1.zz_ ),
345 xt_( tf2.xx_ * tf1.xt_ + tf2.xy_ * tf1.yt_ + tf2.xz_ * tf1.zt_ + tf2.xt_ ),
346 yt_( tf2.yx_ * tf1.xt_ + tf2.yy_ * tf1.yt_ + tf2.yz_ * tf1.zt_ + tf2.yt_ ),
347 zt_( tf2.zx_ * tf1.xt_ + tf2.zy_ * tf1.yt_ + tf2.zz_ * tf1.zt_ + tf2.zt_ )
348 { }
349
350 DISPATCHIMPL( Transform3D );
351
352 Lang::Transform3D::~Transform3D( )
353 {
354 if( planeNormalTransformData_ != 0 )
355 {
356 gsl_matrix_free( planeNormalTransformData_ );
357 // delete planeNormalTransformData_;
358 }
359 }
360
361 Kernel::VariableHandle
362 Lang::Transform3D::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
363 {
364 const size_t N = 3;
365 if( strcmp( fieldID, "p" ) == 0 )
366 {
367 return Helpers::newValHandle( new Lang::Coords3D( xt_, yt_, zt_ ) );
368 }
369 if( strcmp( fieldID, "L" ) == 0 )
370 {
371 return Helpers::newValHandle( new Lang::Transform3D( xx_, yx_, zx_, xy_, yy_, zy_, xz_, yz_, zz_, 0, 0, 0 ) );
372 }
373 if( strcmp( fieldID, "Lx" ) == 0 )
374 {
375 return Helpers::newValHandle( new Lang::FloatTriple( xx_, yx_, zx_ ) );
376 }
377 if( strcmp( fieldID, "Ly" ) == 0 )
378 {
379 return Helpers::newValHandle( new Lang::FloatTriple( xy_, yy_, zy_ ) );
380 }
381 if( strcmp( fieldID, "Lz" ) == 0 )
382 {
383 return Helpers::newValHandle( new Lang::FloatTriple( xz_, yz_, zz_ ) );
384 }
385 if( strcmp( fieldID, "xL" ) == 0 )
386 {
387 return Helpers::newValHandle( new Lang::FloatTriple( xx_, xy_, xz_ ) );
388 }
389 if( strcmp( fieldID, "yL" ) == 0 )
390 {
391 return Helpers::newValHandle( new Lang::FloatTriple( yx_, yy_, yz_ ) );
392 }
393 if( strcmp( fieldID, "zL" ) == 0 )
394 {
395 return Helpers::newValHandle( new Lang::FloatTriple( zx_, zy_, zz_ ) );
396 }
397 if( strcmp( fieldID, "linear?" ) == 0 )
398 {
399 return ( xt_ == 0 && yt_ == 0 && zt_ == 0 ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
400 }
401 if( strcmp( fieldID, "translation?" ) == 0 )
402 {
403 return isTranslation( ) ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
404 }
405 if( strcmp( fieldID, "special?" ) == 0 )
406 {
407 gsl_matrix * A = gsl_matrix_alloc( N, N );
408 gsl_permutation * perm = gsl_permutation_alloc( N );
409 int signum;
410 write_gsl_matrix( A );
411 gsl_linalg_LU_decomp( A, perm, & signum );
412 bool res = gsl_linalg_LU_det( A, signum ) > 0;
413 gsl_matrix_free( A );
414 gsl_permutation_free( perm );
415 return res ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
416 }
417 if( strcmp( fieldID, "Euclidean?" ) == 0 )
418 {
419 gsl_matrix * A = gsl_matrix_alloc( N, N );
420 gsl_vector * SVD_work = gsl_vector_alloc( N );
421 gsl_vector * sigma = gsl_vector_alloc( N );
422 gsl_matrix * V = gsl_matrix_alloc( N, N );
423 write_gsl_matrix( A );
424 gsl_linalg_SV_decomp( A, V, sigma, SVD_work );
425 const double tol = 1e-4;
426 bool res = 1 - tol < gsl_vector_get( sigma, N - 1 ) && gsl_vector_get( sigma, 0 ) < 1 + tol;
427 gsl_matrix_free( V );
428 gsl_vector_free( sigma );
429 gsl_vector_free( SVD_work );
430 gsl_matrix_free( A );
431 return res ? Kernel::THE_TRUE_VARIABLE : Kernel::THE_FALSE_VARIABLE;
432 }
433
434 return TypeID->getMethod( selfRef, fieldID ); /* This will throw if there is no such method. */
435 }
436
437 Lang::Transform3D *
438 Lang::Transform3D::clone( ) const
439 {
440 return new Transform3D( xx_, yx_, zx_,
441 xy_, yy_, zy_,
442 xz_, yz_, zz_,
443 xt_, yt_, zt_ );
444 }
445
446 bool
447 Lang::Transform3D::isIdentity( ) const
448 {
449 return
450 xt_ == Concrete::ZERO_LENGTH && yt_ == Concrete::ZERO_LENGTH && zt_ == Concrete::ZERO_LENGTH &&
451 xx_ == 1 && yy_ == 1 && zz_ == 1 &&
452 xy_ == 0 && xz_ == 0 && yx_ == 0 && yz_ == 0 && zx_ == 0 && zy_ == 0;
453 }
454
455 bool
456 Lang::Transform3D::isTranslation( ) const
457 {
458 return
459 xx_ == 1 && yy_ == 1 && zz_ == 1 &&
460 xy_ == 0 && xz_ == 0 &&
461 yx_ == 0 && yz_ == 0 &&
462 zx_ == 0 && zy_ == 0;
463 }
464
465 void
466 Lang::Transform3D::write_gsl_matrix( gsl_matrix * matrix_3_3 ) const
467 {
468 gsl_matrix_set( matrix_3_3, 0, 0, xx_ );
469 gsl_matrix_set( matrix_3_3, 1, 0, yx_ );
470 gsl_matrix_set( matrix_3_3, 2, 0, zx_ );
471 gsl_matrix_set( matrix_3_3, 0, 1, xy_ );
472 gsl_matrix_set( matrix_3_3, 1, 1, yy_ );
473 gsl_matrix_set( matrix_3_3, 2, 1, zy_ );
474 gsl_matrix_set( matrix_3_3, 0, 2, xz_ );
475 gsl_matrix_set( matrix_3_3, 1, 2, yz_ );
476 gsl_matrix_set( matrix_3_3, 2, 2, zz_ );
477 }
478
479 void
480 Lang::Transform3D::write_gsl_vector( gsl_vector * vec_3 ) const
481 {
482 gsl_vector_set( vec_3, 0, Concrete::Length::offtype( xt_ ) );
483 gsl_vector_set( vec_3, 1, Concrete::Length::offtype( yt_ ) );
484 gsl_vector_set( vec_3, 2, Concrete::Length::offtype( zt_ ) );
485 }
486
487 Concrete::UnitFloatTriple
488 Lang::Transform3D::transformPlaneUnitNormal( const Concrete::UnitFloatTriple & n ) const
489 {
490 const int N = 3;
491 // These statically allocated matrices will leak memory. They could be removed by using a static automaitc
492 // deallocator object. However, since they shall not be deleted by delete (but by gsl_matrix_free), we cannot
493 // us RefCountPtr< gsl_matrix >.
494 static gsl_matrix * a = gsl_matrix_alloc( N, N );
495 static gsl_matrix * v = gsl_matrix_alloc( N, N );
496 static gsl_vector * s = gsl_vector_alloc( N );
497 static gsl_vector * work = gsl_vector_alloc( N );
498
499
500 // static __CLPK_integer mn = N;
501 // static char jobuvt = 'A';
502
503 // static double a[ N * N ];
504 // static double u[ N * N ];
505 // static double vt[ N * N ];
506 // __CLPK_integer ldauvt = N;
507 // static double s[ N ];
508 // __CLPK_integer lwork;
509 // __CLPK_integer info;
510
511 // static __CLPK_doublereal * work = 0;
512 // static RefCountPtr< __CLPK_doublereal > workCleaner;
513
514 // if( work == 0 )
515 // {
516 // // Then we ask LAPACK how much workspace it wants, and then we assume that this number will not change
517 // // as we call DGESVD with other arguments.
518
519 // double tmpwork;
520 // lwork = -1;
521 // dgesvd_( & jobuvt, & jobuvt,
522 // & mn, & mn,
523 // reinterpret_cast< __CLPK_doublereal * >( & a ), & ldauvt,
524 // reinterpret_cast< __CLPK_doublereal * >( & s ),
525 // reinterpret_cast< __CLPK_doublereal * >( & u ), & ldauvt,
526 // reinterpret_cast< __CLPK_doublereal * >( & vt ), & ldauvt,
527 // reinterpret_cast< __CLPK_doublereal * >( & tmpwork ), & lwork,
528 // & info );
529 // lwork = static_cast< __CLPK_integer >( tmpwork );
530 // work = new __CLPK_doublereal[ lwork ];
531 // workCleaner = RefCountPtr< __CLPK_doublereal >( work );
532 // }
533
534
535 if( planeNormalTransformData_ == 0 )
536 {
537 // This is the first time this transform is used to transform a unit plane normal.
538 // The linear part of this transform must then be computed, and we use the singular
539 // value decomposition for this.
540
541 planeNormalTransformData_ = gsl_matrix_alloc( N, N );
542
543 write_gsl_matrix( a );
544
545 // std::cerr << "Here's a:" << std::endl ;
546 // displayArray( std::cerr, a );
547
548 {
549 int status = gsl_linalg_SV_decomp( a, v, s, work );
550 if( status != 0 )
551 {
552 throw Exceptions::ExternalError( "Gnu Scientific Library SVD routine failed." );
553 }
554 }
555
556 // a[ 0 ] = xx_;
557 // a[ 1 ] = yx_;
558 // a[ 2 ] = zx_;
559 // a[ 3 ] = xy_;
560 // a[ 4 ] = yy_;
561 // a[ 5 ] = zy_;
562 // a[ 6 ] = xz_;
563 // a[ 7 ] = yz_;
564 // a[ 8 ] = zz_;
565
566 // dgesvd_( & jobuvt, & jobuvt,
567 // & mn, & mn,
568 // reinterpret_cast< __CLPK_doublereal * >( & a ), & ldauvt,
569 // reinterpret_cast< __CLPK_doublereal * >( & s ),
570 // reinterpret_cast< __CLPK_doublereal * >( & u ), & ldauvt,
571 // reinterpret_cast< __CLPK_doublereal * >( & vt ), & ldauvt,
572 // reinterpret_cast< __CLPK_doublereal * >( work ), & lwork,
573 // & info );
574
575 // if( info != 0 )
576 // {
577 // throw Exceptions::ExternalError( "LAPACK routine DGESVD failed." );
578 // }
579
580 if( gsl_vector_get( s, 1 ) < 1e-5 )
581 {
582 throw Exceptions::AffineTransformKillsPlane( gsl_vector_get( s, 1 ) );
583 }
584
585 // std::cerr << "Here's s:" << std::endl ;
586 // gsl_vector_fprintf( stderr, s, "%f" );
587
588 gsl_vector_set( s, 0, gsl_vector_get( s, 2 ) / gsl_vector_get( s, 0 ) );
589 gsl_vector_set( s, 1, gsl_vector_get( s, 2 ) / gsl_vector_get( s, 1 ) );
590 // s[ 2 ] = 1;
591
592 // std::cerr << "Here's the modified s:" << std::endl ;
593 // gsl_vector_fprintf( stderr, s, "%f" );
594
595
596 // if( s[ 1 ] < 1e-5 )
597 // {
598 // throw Exceptions::AffineTransformKillsPlane( s[ 1 ] );
599 // }
600
601 // s[ 0 ] = s[ 2 ] / s[ 0 ];
602 // s[ 1 ] = s[ 2 ] / s[ 1 ];
603 // // s[ 2 ] = 1;
604
605 // We will now compute " u * diag( s ) * vt ".
606
607 // Note that "u" is stored in a when gsl_linalg_SV_decomp is used.
608
609 // std::cerr << "Here's u:" << std::endl ;
610 // displayArray( std::cerr, a );
611
612 gsl_matrix_set( a, 0, 0, gsl_matrix_get( a, 0, 0 ) * gsl_vector_get( s, 0 ) );
613 gsl_matrix_set( a, 1, 0, gsl_matrix_get( a, 1, 0 ) * gsl_vector_get( s, 0 ) );
614 gsl_matrix_set( a, 2, 0, gsl_matrix_get( a, 2, 0 ) * gsl_vector_get( s, 0 ) );
615 gsl_matrix_set( a, 0, 1, gsl_matrix_get( a, 0, 1 ) * gsl_vector_get( s, 1 ) );
616 gsl_matrix_set( a, 1, 1, gsl_matrix_get( a, 1, 1 ) * gsl_vector_get( s, 1 ) );
617 gsl_matrix_set( a, 2, 1, gsl_matrix_get( a, 2, 1 ) * gsl_vector_get( s, 1 ) );
618 // Note that s[ 2 ] == 1
619
620 // u[ 0 ] *= s[ 0 ];
621 // u[ 1 ] *= s[ 0 ];
622 // u[ 2 ] *= s[ 0 ];
623 // u[ 3 ] *= s[ 1 ];
624 // u[ 4 ] *= s[ 1 ];
625 // u[ 5 ] *= s[ 1 ];
626 // // Note that s[ 2 ] == 1
627
628 // std::cerr << "Here's the modified a:" << std::endl ;
629 // displayArray( std::cerr, a );
630
631 // std::cerr << "Here's v:" << std::endl ;
632 // displayArray( std::cerr, v );
633
634 gsl_blas_dgemm( CblasNoTrans,
635 CblasTrans,
636 1.,
637 a,
638 v,
639 0.,
640 planeNormalTransformData_ );
641
642 // std::cerr << "Here's the matrix:" << std::endl ;
643 // displayArray( std::cerr, planeNormalTransformData_ );
644
645 // cblas_dgemm( CblasColMajor, CblasNoTrans, CblasNoTrans,
646 // N, N, N,
647 // 1.,
648 // u, N,
649 // vt, N,
650 // 0., planeNormalTransformData_, N );
651 }
652
653 // Now that the linear, not too singular, transform has been computed, we just apply it and normalize the result.
654 // The normalization is made by the UnitFloatTriple constructor.
655
656 static gsl_vector * _n = gsl_vector_alloc( N );
657 static gsl_vector * res = gsl_vector_alloc( N );
658
659 // static double _n[ N ];
660 // static double res[ N ];
661
662 gsl_vector_set( _n, 0, n.x_ );
663 gsl_vector_set( _n, 1, n.y_ );
664 gsl_vector_set( _n, 2, n.z_ );
665
666 // _n[ 0 ] = n.x_;
667 // _n[ 1 ] = n.y_;
668 // _n[ 2 ] = n.z_;
669
670 // std::cerr << "Input vector: " << std::endl ;
671 // gsl_vector_fprintf( stderr, _n, "%f" );
672 // std::cerr << std::endl ;
673
674 gsl_blas_dgemv( CblasNoTrans,
675 1.,
676 planeNormalTransformData_,
677 _n,
678 0.,
679 res );
680
681 // std::cerr << "Result: " << std::endl ;
682 // gsl_vector_fprintf( stderr, res, "%f" );
683 // std::cerr << std::endl ;
684
685 // cblas_dgemv( CblasColMajor, CblasNoTrans,
686 // N, N,
687 // 1.,
688 // planeNormalTransformData_, N,
689 // reinterpret_cast< double * >( & _n ), 1,
690 // 0., reinterpret_cast< double * >( & res ), 1 );
691
692 return Concrete::UnitFloatTriple( gsl_vector_get( res, 0 ),
693 gsl_vector_get( res, 1 ),
694 gsl_vector_get( res, 2 ) );
695 // return Concrete::UnitFloatTriple( res[0], res[1], res[2] );
696
697 /*
698 {
699 // First we compute a unit vector in the plane
700 static const Concrete::UnitFloatTriple xHat( 1, 0, 0 );
701 static const Concrete::UnitFloatTriple yHat( 0, 1, 0 );
702 Concrete::UnitFloatTriple r1 = Shapes::cross( unitNormal_, xHat );
703 Concrete::UnitFloatTriple r2 = Shapes::cross( unitNormal_, yHat );
704 Concrete::UnitFloatTriple r( 0, 0, 0 );
705 if( r1.norm( ) > r2.norm( ) )
706 {
707 r = r1.normalized( );
708 }
709 else
710 {
711 r = r2.normalized( );
712 }
713
714 // Then we find one point that is in the plane
715 double ax = fabs( unitNormal_.x_ );
716 double ay = fabs( unitNormal_.y_ );
717 double az = fabs( unitNormal_.z_ );
718
719 Concrete::Coords3D x0( 0, 0, 0 );
720 if( ax >= ay && ax >= az )
721 {
722 x0 = Concrete::Coords3D( m_ / unitNormal_.x_, 0, 0 );
723 }
724 else if( ay >= az )
725 {
726 x0 = Concrete::Coords3D( 0, m_ / unitNormal_.y_, 0 );
727 }
728 else
729 {
730 x0 = Concrete::Coords3D( 0, 0, m_ / unitNormal_.z_ );
731 }
732
733 // Now it is easy to find two more points that span the plane together with x0
734 Concrete::Coords3D x1 = x0 + r;
735 Concrete::Coords3D x2 = x0 + Shapes::cross( unitNormal_, r );
736
737 // Now we see where these points go...
738 Concrete::Coords3D Tx0 = x0.transformed( tf );
739 Concrete::Coords3D Tx1 = x1.transformed( tf );
740 Concrete::Coords3D Tx2 = x2.transformed( tf );
741
742 // ... from which the new equation may be computed.
743 Concrete::UnitFloatTriple Tnormal = Shapes::cross( Tx1 - Tx0, Tx2 - Tx0 );
744 double TnormalNorm = Tnormal.norm( );
745 if( TnormalNorm == 0 )
746 {
747 // A polygon of lower dimension is invisible, so we may just return without pushing any triangles.
748 return;
749 }
750 Concrete::UnitFloatTriple TunitNormal = Tnormal * ( 1 / TnormalNorm );
751 */
752 }
753
754 void
755 Lang::Transform3D::show( std::ostream & os ) const
756 {
757 os << "[ ("
758 << xx_ << ", " << yx_ << ", " << zx_ << ") ("
759 << xy_ << ", " << yy_ << ", " << zy_ << ") ("
760 << xz_ << ", " << yz_ << ", " << zz_ << ") ("
761 << Lang::Length( xt_ ) << ", " << Lang::Length( yt_ ) << ", " << Lang::Length( zt_ ) << ") ]" ;
762 }
763
764
765 Kernel::Arguments::Arguments( const Kernel::EvaluatedFormals * formals )
766 : formals_( formals ), variables_( new Environment::ValueVector::ValueType ), dst_( 0 ),
767 hasSink_( formals_->formals_->hasSink( ) ),
768 dstEnd_( formals_->formals_->defaultExprs_.size( ) ),
769 isSink_( formals_->isSink_ ),
770 sinkArgList_( 0 ), sinkValues_( NullPtr< const Lang::SingleList >( ) ),
771 states_( new Environment::StateVector::ValueType ), stateDst_( 0 ),
772 mutatorSelf_( 0 )
773 {
774 if( hasSink_ )
775 {
776 sinkArgList_ = new Ast::ArgListExprs( false ); // This is not an expression-owner.
777 sinkValues_ = Lang::THE_CONS_NULL;
778 if( formals_->formals_->argumentOrder_->empty( ) )
779 {
780 // All arguments go in the sink.
781 dst_ = INT_MAX;
782 }
783 }
784 // Thinking of all the evaluated cuts, it actually makes some sense not to reserve memory here.
785 // variables_.reserve( formals_->argumentOrder_->size( ) );
786 // states_.reserve( formals_->stateOrder_->size( ) );
787 }
788
789 Kernel::Arguments::~Arguments( )
790 { }
791
792 Kernel::Arguments
793 Kernel::Arguments::clone( ) const
794 {
795 CHECK(
796 if( ! states_->empty( ) )
797 {
798 throw Exceptions::InternalError( "Arguments with states may not be cloned." );
799 }
800 );
801
802 Kernel::Arguments res( formals_ );
803
804 res.variables_->reserve( variables_->size( ) );
805 {
806 typedef typeof *variables_ ListType;
807 for( ListType::const_iterator i = variables_->begin( ); i != variables_->end( ); ++i )
808 {
809 res.variables_->push_back( *i );
810 }
811 }
812 res.locations_ = locations_;
813 res.dst_ = dst_;
814 if( sinkArgList_ != 0 )
815 {
816 throw Exceptions::NotImplemented( "Cloning of arguments with sink." );
817 //res.sinkArgList_ = sinkArgList_->clone( );
818 res.sinkValues_ = sinkValues_;
819 }
820
821 return res;
822 }
823
824
825 void
826 Kernel::Arguments::addOrderedArgument( const Kernel::VariableHandle & arg, Ast::Expression * loc )
827 {
828 /* Recall that if there's a sink, this will be the last argument.
829 */
830 if( ! isSink_ &&
831 dst_ >= dstEnd_ )
832 {
833 /* If there is a sink, put it there. Otherwise, we have detected an arity mismatch, but to generate a good
834 * error message we don't throw the message from here, but rest assured that an error will be delivered in
835 * due time when applyDefaults is invoked.
836 */
837 if( hasSink_ )
838 {
839 sinkArgList_->orderedExprs_->push_back( loc );
840 sinkValues_ = RefCountPtr< Lang::SingleList >( new Lang::SingleListPair( arg, sinkValues_ ) );
841 }
842 else
843 {
844 variables_->push_back( arg );
845 locations_.push_back( loc );
846 ++dst_; // I'm not sure this is meaningful here...
847 }
848 }
849 else if( dst_ == variables_->size( ) )
850 {
851 variables_->push_back( arg );
852 locations_.push_back( loc );
853 ++dst_;
854 }
855 else
856 {
857 (*variables_)[ dst_ ] = arg;
858 locations_[ dst_ ] = loc;
859 while( dst_ < variables_->size( ) &&
860 (*variables_)[ dst_ ] != Kernel::THE_SLOT_VARIABLE )
861 {
862 ++dst_;
863 }
864 }
865 }
866
867 void
868 Kernel::Arguments::addNamedArgument( const char * id, const Kernel::VariableHandle & arg, Ast::Expression * loc )
869 {
870 if( formals_ == 0 )
871 {
872 throw Exceptions::CoreNoNamedFormals( "???" );
873 }
874
875 typedef typeof *(formals_->formals_->argumentOrder_) FormalsMapType;
876 FormalsMapType & formalsMap = *(formals_->formals_->argumentOrder_);
877
878 /* Note that the name of the sink is invisible, so referring to it is just another arguments which is
879 * put in the sink. This variable happens to have the same name as the sink.
880 */
881 FormalsMapType::const_iterator j = formalsMap.find( id );
882 if( j == formalsMap.end( ) ||
883 ( hasSink_ &&
884 j->second == dstEnd_ ) )
885 {
886 if( hasSink_ )
887 {
888 if( sinkArgList_->namedExprs_->find( id ) != sinkArgList_->namedExprs_->end( ) )
889 {
890 throw Exceptions::InternalError( "It is a surprise that the sink got a repeated formal." );
891 }
892 sinkArgList_->namedExprs_->insert( std::pair< const char *, Ast::Expression * >( id, loc ) );
893 sinkValues_ = RefCountPtr< Lang::SingleList >( new Lang::SingleListPair( arg, sinkValues_ ) );
894 return;
895 }
896 throw Exceptions::NamedFormalMismatch( formals_->formals_->loc( ), strrefdup( id ), Exceptions::NamedFormalMismatch::VARIABLE );
897 }
898 size_t pos = j->second;
899
900 if( pos < dst_ )
901 {
902 throw Exceptions::NamedFormalAlreadySpecified( formals_->formals_->loc( ), strrefdup( id ), pos, Exceptions::NamedFormalAlreadySpecified::VARIABLE );
903 }
904
905 if( pos >= variables_->size( ) )
906 {
907 while( variables_->size( ) < pos )
908 {
909 variables_->push_back( Kernel::THE_SLOT_VARIABLE );
910 locations_.push_back( 0 );
911 }
912 variables_->push_back( arg );
913 locations_.push_back( loc );
914 }
915 else
916 {
917 if( (*variables_)[ pos ] != Kernel::THE_SLOT_VARIABLE )
918 {
919 throw Exceptions::NamedFormalAlreadySpecified( formals_->formals_->loc( ), strrefdup( id ), pos, Exceptions::NamedFormalAlreadySpecified::VARIABLE );
920 }
921 (*variables_)[ pos ] = arg;
922 locations_[ pos ] = loc;
923 }
924 if( pos == dst_ )
925 {
926 while( dst_ < variables_->size( ) &&
927 (*variables_)[ dst_ ] != Kernel::THE_SLOT_VARIABLE )
928 {
929 ++dst_;
930 }
931 }
932 }
933
934 void
935 Kernel::Arguments::addOrderedState( const Kernel::StateHandle & state, Ast::Node * loc )
936 {
937 if( stateDst_ == states_->size( ) )
938 {
939 states_->push_back( state );
940 stateLocations_.push_back( loc );
941 ++stateDst_;
942 }
943 else
944 {
945 (*states_)[ stateDst_ ] = state;
946 stateLocations_[ stateDst_ ] = loc;
947 while( stateDst_ < states_->size( ) &&
948 (*states_)[ stateDst_ ] != Kernel::THE_SLOT_STATE )
949 {
950 ++stateDst_;
951 }
952 }
953 }
954
955 void
956 Kernel::Arguments::addNamedState( const char * id, const Kernel::StateHandle & state, Ast::Node * loc )
957 {
958 if( formals_ == 0 )
959 {
960 throw Exceptions::CoreNoNamedFormals( "???" );
961 }
962
963 typedef typeof *(formals_->formals_->stateOrder_) FormalsMapType;
964 FormalsMapType & formalsMap = *(formals_->formals_->stateOrder_);
965
966 FormalsMapType::const_iterator j = formalsMap.find( id );
967 if( j == formalsMap.end( ) )
968 {
969 throw Exceptions::NamedFormalMismatch( formals_->formals_->loc( ), strrefdup( id ), Exceptions::NamedFormalMismatch::STATE );
970 }
971 size_t pos = j->second;
972
973 if( pos < stateDst_ )
974 {
975 throw Exceptions::NamedFormalAlreadySpecified( formals_->formals_->loc( ), strrefdup( id ), pos, Exceptions::NamedFormalAlreadySpecified::STATE );
976 }
977
978 if( pos >= states_->size( ) )
979 {
980 while( states_->size( ) < pos )
981 {
982 states_->push_back( Kernel::THE_SLOT_STATE );
983 stateLocations_.push_back( 0 );
984 }
985 states_->push_back( state );
986 stateLocations_.push_back( loc );
987 }
988 else
989 {
990 if( (*states_)[ pos ] != Kernel::THE_SLOT_STATE )
991 {
992 throw Exceptions::NamedFormalAlreadySpecified( formals_->formals_->loc( ), strrefdup( id ), pos, Exceptions::NamedFormalAlreadySpecified::STATE );
993 }
994 (*states_)[ pos ] = state;
995 stateLocations_[ pos ] = loc;
996 }
997 if( pos == stateDst_ )
998 {
999 while( stateDst_ < states_->size( ) &&
1000 (*states_)[ stateDst_ ] != Kernel::THE_SLOT_STATE )
1001 {
1002 ++stateDst_;
1003 }
1004 }
1005 }
1006
1007 void
1008 Kernel::Arguments::applyDefaults( )
1009 {
1010 if( formals_ == 0 )
1011 {
1012 return;
1013 }
1014
1015 size_t numberOfArguments = variables_->size( );
1016 size_t formalsSize = formals_->defaults_.size( );
1017
1018 if( numberOfArguments > formalsSize &&
1019 ! hasSink_ )
1020 {
1021 /* The location of the ball must be set by the caller. */
1022 throw Exceptions::UserArityMismatch( formals_->formals_->loc( ), formalsSize, numberOfArguments, Exceptions::UserArityMismatch::VARIABLE );
1023 }
1024
1025 size_t numberOfStates = states_->size( );
1026 size_t formalsStateSize = formals_->formals_->stateOrder_->size( );
1027 if( numberOfStates > formalsStateSize )
1028 {
1029 /* The location of the ball must be set by the caller. */
1030 throw Exceptions::UserArityMismatch( formals_->formals_->loc( ), formalsStateSize, numberOfStates, Exceptions::UserArityMismatch::STATE );
1031 }
1032
1033 /* First the easy part: All states must be specified.
1034 */
1035 std::map< size_t, RefCountPtr< const char > > * missingStates = 0;
1036 {
1037 size_t pos = 0;
1038 typedef typeof *states_ ListType;
1039 for( ListType::const_iterator i = states_->begin( ); i != states_->end( ); ++i, ++pos )
1040 {
1041 if( *i == Kernel::THE_SLOT_STATE )
1042 {
1043 if( missingStates == 0 )
1044 {
1045 missingStates = new typeof *missingStates;
1046 }
1047 typedef typeof *(formals_->formals_->stateOrder_) FormalsMapType;
1048 FormalsMapType & formalsMap = *(formals_->formals_->stateOrder_);
1049 for( FormalsMapType::const_iterator i = formalsMap.begin( ); ; )
1050 {
1051 if( i->second == pos )
1052 {
1053 missingStates->insert( missingStates->begin( ), std::pair< size_t, RefCountPtr< const char > >( pos, strrefdup( i->first ) ) );
1054 break;
1055 }
1056 ++i;
1057 if( i == formalsMap.end( ) )
1058 {
1059 throw Exceptions::InternalError( "Failed to find position of missing state." );
1060 }
1061 }
1062
1063 }
1064 }
1065
1066 if( numberOfStates < formalsStateSize )
1067 {
1068 if( missingStates == 0 )
1069 {
1070 missingStates = new typeof *missingStates;
1071 }
1072 typedef typeof *(formals_->formals_->stateOrder_) FormalsMapType;
1073 FormalsMapType & formalsMap = *(formals_->formals_->stateOrder_);
1074 FormalsMapType::const_iterator i = formalsMap.begin( );
1075 for( size_t j = 0; j < numberOfStates; ++j )
1076 {
1077 ++i;
1078 }
1079
1080 for( ; i != formalsMap.end( ); ++i, ++pos)
1081 {
1082 missingStates->insert( missingStates->begin( ), std::pair< size_t, RefCountPtr< const char > >( pos, strrefdup( i->first ) ) );
1083 }
1084
1085 }
1086 }
1087
1088 /* Allocate positions in the vector for all arguments.
1089 */
1090 variables_->reserve( hasSink_ ? formalsSize + 1 : formalsSize );
1091 while( variables_->size( ) < formalsSize )
1092 {
1093 variables_->push_back( Kernel::THE_SLOT_VARIABLE );
1094 }
1095 locations_.resize( formalsSize );
1096
1097 typedef typeof *variables_ MyListType;
1098 typedef typeof formals_->defaults_ DefaultListType;
1099 typedef typeof formals_->locations_ LocationListType;
1100 DefaultListType::const_iterator src = formals_->defaults_.begin( );
1101 LocationListType::const_iterator srcLoc = formals_->locations_.begin( );
1102 std::map< size_t, RefCountPtr< const char > > * missingArgs = 0;
1103 size_t pos = 0;
1104 typedef typeof locations_ MyLocationsType;
1105 for( MyListType::iterator dst = variables_->begin( ); dst != variables_->end( ); ++dst, ++src, ++srcLoc, ++pos )
1106 {
1107 if( *dst == Kernel::THE_SLOT_VARIABLE )
1108 {
1109 /* Handle error situation.
1110 */
1111 if( *src == Kernel::THE_SLOT_VARIABLE )
1112 {
1113 if( missingArgs == 0 )
1114 {
1115 missingArgs = new typeof *missingArgs;
1116 }
1117 typedef typeof *(formals_->formals_->argumentOrder_) FormalsMapType;
1118 FormalsMapType & formalsMap = *(formals_->formals_->argumentOrder_);
1119 for( FormalsMapType::const_iterator i = formalsMap.begin( ); ; )
1120 {
1121 if( i->second == pos )
1122 {
1123 missingArgs->insert( missingArgs->begin( ), std::pair< size_t, RefCountPtr< const char > >( pos, strrefdup( i->first ) ) );
1124 break;
1125 }
1126 ++i;
1127 if( i == formalsMap.end( ) )
1128 {
1129 throw Exceptions::InternalError( "Failed to find position of missing argument." );
1130 }
1131 }
1132 }
1133
1134 /* Normal case.
1135 */
1136 *dst = *src;
1137 locations_[ pos ] = *srcLoc;
1138 }
1139 }
1140
1141 if( missingArgs != 0 || missingStates != 0 )
1142 {
1143 throw Exceptions::MissingArguments( formals_->formals_->loc( ), missingArgs, missingStates );
1144 }
1145
1146 if( hasSink_ )
1147 {
1148 variables_->push_back
1149 ( Helpers::newValHandle
1150 ( new Lang::Structure( sinkArgList_,
1151 sinkValues_,
1152 true ) ) ); // true means that the sinkArgList_ gets owned by the Structure.
1153 sinkArgList_ = 0;
1154 }
1155 }
1156
1157
1158 Kernel::VariableHandle &
1159 Kernel::Arguments::getHandle( size_t i )
1160 {
1161 return (*variables_)[ i ];
1162 }
1163
1164 RefCountPtr< const Lang::Value > &
1165 Kernel::Arguments::getValue( size_t i )
1166 {
1167 return (*variables_)[ i ]->getUntyped( );
1168 }
1169
1170 const Ast::SourceLocation &
1171 Kernel::Arguments::getLoc( size_t i ) const
1172 {
1173 return locations_[ i ]->loc( );
1174 }
1175
1176 const Ast::Node *
1177 Kernel::Arguments::getNode( size_t i ) const
1178 {
1179 return locations_[ i ];
1180 }
1181
1182 Kernel::Thunk *
1183 Kernel::Arguments::getThunk( size_t i )
1184 {
1185 return (*variables_)[ i ]->copyThunk( );
1186 }
1187
1188 bool
1189 Kernel::Arguments::isSlot( size_t i ) const
1190 {
1191 return (*variables_)[ i ] == Kernel::THE_SLOT_VARIABLE;
1192 }
1193
1194 Kernel::StateHandle
1195 Kernel::Arguments::getState( size_t i )
1196 {
1197 return (*states_)[ i ];
1198 }
1199
1200 const Ast::SourceLocation &
1201 Kernel::Arguments::getStateLoc( size_t i ) const
1202 {
1203 return stateLocations_[ i ]->loc( );
1204 }
1205
1206 size_t
1207 Kernel::Arguments::size( ) const
1208 {
1209 return variables_->size( );
1210 }
1211
1212 bool
1213 Kernel::Arguments::empty( ) const
1214 {
1215 return variables_->empty( );
1216 }
1217
1218 void
1219 Kernel::Arguments::setMutatorSelf( Kernel::StateHandle mutatorSelf )
1220 {
1221 mutatorSelf_ = mutatorSelf;
1222 }
1223
1224 Kernel::StateHandle
1225 Kernel::Arguments::getMutatorSelf( )
1226 {
1227 if( mutatorSelf_ == 0 )
1228 {
1229 throw Exceptions::InternalError( "Kernel::Arguments::getMutatorSelf: self is null." );
1230 }
1231 return mutatorSelf_;
1232 }
1233
1234 void
1235 Kernel::Arguments::gcMark( Kernel::GCMarkedSet & marked )
1236 {
1237 {
1238 typedef typeof *variables_ ListType;
1239 for( ListType::const_iterator i = variables_->begin( ); i != variables_->end( ); ++i )
1240 {
1241 const_cast< Kernel::Variable * >( i->getPtr( ) )->gcMark( marked );
1242 }
1243 }
1244 }
1245
1246 Kernel::Environment::ValueVector
1247 Kernel::Arguments::getVariables( )
1248 {
1249 return variables_;
1250 }
1251
1252 Kernel::Environment::StateVector
1253 Kernel::Arguments::getStates( )
1254 {
1255 return states_;
1256 }
1257
1258
1259 namespace Shapes
1260 {
1261 namespace Kernel
1262 {
1263
1264 class FunctionOneHandleCont : public Kernel::Continuation
1265 {
1266 RefCountPtr< const Lang::Function > fun_;
1267 Kernel::PassedDyn dyn_;
1268 Kernel::ContRef cont_;
1269 public:
1270 FunctionOneHandleCont( const RefCountPtr< const Lang::Function > & fun, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1271 : Kernel::Continuation( traceLoc ), fun_( fun ), dyn_( dyn ), cont_( cont )
1272 { }
1273 virtual ~FunctionOneHandleCont( ) { }
1274 virtual void takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
1275 {
1276 /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
1277 * However, this continuation takes handles anyway, since handles is what goes into the argument list.
1278 */
1279
1280 if( val->isThunk( ) )
1281 {
1282 val->force( val, evalState );
1283 return;
1284 }
1285
1286 Kernel::Arguments args = fun_->newCurriedArguments( );
1287 args.addOrderedArgument( val, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1288
1289 evalState->dyn_ = dyn_;
1290 evalState->cont_ = cont_;
1291 fun_->call( evalState, args, traceLoc_ );
1292 }
1293 virtual Kernel::ContRef up( ) const
1294 {
1295 return cont_;
1296 }
1297 virtual RefCountPtr< const char > description( ) const
1298 {
1299 return strrefdup( "internal function call with one handle" );
1300 }
1301 virtual void gcMark( Kernel::GCMarkedSet & marked )
1302 {
1303 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
1304 dyn_->gcMark( marked );
1305 cont_->gcMark( marked );
1306 }
1307 };
1308
1309 class FunctionTwoHandlesCont_2 : public Kernel::Continuation
1310 {
1311 RefCountPtr< const Lang::Function > fun_;
1312 Kernel::VariableHandle arg1_;
1313 Kernel::PassedDyn dyn_;
1314 Kernel::ContRef cont_;
1315 public:
1316 FunctionTwoHandlesCont_2( const RefCountPtr< const Lang::Function > & fun, const Kernel::VariableHandle & arg1, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1317 : Kernel::Continuation( traceLoc ), fun_( fun ), arg1_( arg1 ), dyn_( dyn ), cont_( cont )
1318 { }
1319 virtual ~FunctionTwoHandlesCont_2( ) { }
1320 virtual void takeHandle( Kernel::VariableHandle arg2, Kernel::EvalState * evalState, bool dummy ) const
1321 {
1322 /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
1323 * However, this continuation takes handles anyway, since handles is what goes into the argument list.
1324 */
1325
1326 if( arg2->isThunk( ) )
1327 {
1328 arg2->force( arg2, evalState );
1329 return;
1330 }
1331
1332 Kernel::Arguments args = fun_->newCurriedArguments( );
1333 args.addOrderedArgument( arg1_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1334 args.addOrderedArgument( arg2, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1335 evalState->dyn_ = dyn_;
1336 evalState->cont_ = cont_;
1337 fun_->call( evalState, args, traceLoc_ );
1338 }
1339 virtual Kernel::ContRef up( ) const
1340 {
1341 return cont_;
1342 }
1343 virtual RefCountPtr< const char > description( ) const
1344 {
1345 return strrefdup( "internal function call with two handles, second" );
1346 }
1347 virtual void gcMark( Kernel::GCMarkedSet & marked )
1348 {
1349 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
1350 dyn_->gcMark( marked );
1351 cont_->gcMark( marked );
1352 }
1353 };
1354
1355 class FunctionTwoHandlesCont_1 : public Kernel::Continuation
1356 {
1357 RefCountPtr< const Lang::Function > fun_;
1358 Kernel::VariableHandle arg2_;
1359 bool forceArg2_;
1360 Kernel::PassedDyn dyn_;
1361 Kernel::ContRef cont_;
1362 public:
1363 FunctionTwoHandlesCont_1( const RefCountPtr< const Lang::Function > & fun, const Kernel::VariableHandle & arg2, bool forceArg2, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1364 : Kernel::Continuation( traceLoc ), fun_( fun ), arg2_( arg2 ), forceArg2_( forceArg2 ), dyn_( dyn ), cont_( cont )
1365 { }
1366 virtual ~FunctionTwoHandlesCont_1( ) { }
1367 virtual void takeHandle( Kernel::VariableHandle arg1, Kernel::EvalState * evalState, bool dummy ) const
1368 {
1369 /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
1370 * However, this continuation takes handles anyway, since handles is what goes into the argument list.
1371 */
1372
1373 if( arg1->isThunk( ) )
1374 {
1375 arg1->force( arg1, evalState );
1376 return;
1377 }
1378
1379 if( forceArg2_ )
1380 {
1381 Kernel::ContRef newCont = Kernel::ContRef( new Kernel::FunctionTwoHandlesCont_2( fun_, arg1, dyn_, cont_, traceLoc_ ) );
1382 evalState->cont_ = newCont;
1383 newCont->takeHandle( arg2_, evalState );
1384 return;
1385 }
1386
1387 /* The second handle need not be forced
1388 */
1389 Kernel::Arguments args = fun_->newCurriedArguments( );
1390 args.addOrderedArgument( arg1, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1391 args.addOrderedArgument( arg2_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1392 evalState->dyn_ = dyn_;
1393 evalState->cont_ = cont_;
1394 fun_->call( evalState, args, traceLoc_ );
1395 }
1396 virtual Kernel::ContRef up( ) const
1397 {
1398 return cont_;
1399 }
1400 virtual RefCountPtr< const char > description( ) const
1401 {
1402 return strrefdup( "internal function call with two handles, first" );
1403 }
1404 virtual void gcMark( Kernel::GCMarkedSet & marked )
1405 {
1406 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
1407 dyn_->gcMark( marked );
1408 cont_->gcMark( marked );
1409 }
1410 };
1411
1412 class FunctionTwoHandlesOneStateCont_2 : public Kernel::Continuation
1413 {
1414 RefCountPtr< const Lang::Function > fun_;
1415 Kernel::VariableHandle arg1_;
1416 Kernel::StateHandle state_;
1417 Kernel::PassedDyn dyn_;
1418 Kernel::ContRef cont_;
1419 public:
1420 FunctionTwoHandlesOneStateCont_2( const RefCountPtr< const Lang::Function > & fun, const Kernel::VariableHandle & arg1, Kernel::StateHandle state, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1421 : Kernel::Continuation( traceLoc ), fun_( fun ), arg1_( arg1 ), state_( state ), dyn_( dyn ), cont_( cont )
1422 { }
1423 virtual ~FunctionTwoHandlesOneStateCont_2( ) { }
1424 virtual void takeHandle( Kernel::VariableHandle arg2, Kernel::EvalState * evalState, bool dummy ) const
1425 {
1426 /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
1427 * However, this continuation takes handles anyway, since handles is what goes into the argument list.
1428 */
1429
1430 if( arg2->isThunk( ) )
1431 {
1432 arg2->force( arg2, evalState );
1433 return;
1434 }
1435
1436 Kernel::Arguments args = fun_->newCurriedArguments( );
1437 args.addOrderedArgument( arg1_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1438 args.addOrderedArgument( arg2, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1439 args.addOrderedState( state_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1440 evalState->dyn_ = dyn_;
1441 evalState->cont_ = cont_;
1442 fun_->call( evalState, args, traceLoc_ );
1443 }
1444 virtual Kernel::ContRef up( ) const
1445 {
1446 return cont_;
1447 }
1448 virtual RefCountPtr< const char > description( ) const
1449 {
1450 return strrefdup( "internal function call with two handles and one state, second" );
1451 }
1452 virtual void gcMark( Kernel::GCMarkedSet & marked )
1453 {
1454 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
1455 state_->gcMark( marked );
1456 dyn_->gcMark( marked );
1457 cont_->gcMark( marked );
1458 }
1459 };
1460
1461 class FunctionTwoHandlesOneStateCont_1 : public Kernel::Continuation
1462 {
1463 RefCountPtr< const Lang::Function > fun_;
1464 Kernel::VariableHandle arg2_;
1465 bool forceArg2_;
1466 Kernel::StateHandle state_;
1467 Kernel::PassedDyn dyn_;
1468 Kernel::ContRef cont_;
1469 public:
1470 FunctionTwoHandlesOneStateCont_1( const RefCountPtr< const Lang::Function > & fun, const Kernel::VariableHandle & arg2, bool forceArg2, Kernel::StateHandle state, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
1471 : Kernel::Continuation( traceLoc ), fun_( fun ), arg2_( arg2 ), forceArg2_( forceArg2 ), state_( state ), dyn_( dyn ), cont_( cont )
1472 { }
1473 virtual ~FunctionTwoHandlesOneStateCont_1( ) { }
1474 virtual void takeHandle( Kernel::VariableHandle arg1, Kernel::EvalState * evalState, bool dummy ) const
1475 {
1476 /* This continuation really seeks forced arguments, for otherwise a thunk would have been generated directly.
1477 * However, this continuation takes handles anyway, since handles is what goes into the argument list.
1478 */
1479
1480 if( arg1->isThunk( ) )
1481 {
1482 arg1->force( arg1, evalState );
1483 return;
1484 }
1485
1486 if( forceArg2_ )
1487 {
1488 Kernel::ContRef newCont = Kernel::ContRef( new Kernel::FunctionTwoHandlesOneStateCont_2( fun_, arg1, state_, dyn_, cont_, traceLoc_ ) );
1489 evalState->cont_ = newCont;
1490 newCont->takeHandle( arg2_, evalState );
1491 return;
1492 }
1493
1494 /* The second handle need not be forced
1495 */
1496 Kernel::Arguments args = fun_->newCurriedArguments( );
1497 args.addOrderedArgument( arg1, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1498 args.addOrderedArgument( arg2_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1499 args.addOrderedState( state_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1500 evalState->dyn_ = dyn_;
1501 evalState->cont_ = cont_;
1502 fun_->call( evalState, args, traceLoc_ );
1503 }
1504 virtual Kernel::ContRef up( ) const
1505 {
1506 return cont_;
1507 }
1508 virtual RefCountPtr< const char > description( ) const
1509 {
1510 return strrefdup( "internal function call with two handles and one state, first" );
1511 }
1512 virtual void gcMark( Kernel::GCMarkedSet & marked )
1513 {
1514 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
1515 dyn_->gcMark( marked );
1516 cont_->gcMark( marked );
1517 state_->gcMark( marked );
1518 }
1519 };
1520
1521 }
1522 }
1523
1524
1525 Lang::Function::Function( Kernel::EvaluatedFormals * formals )
1526 : formals_( formals )
1527 { }
1528
1529 DISPATCHIMPL( Function );
1530
1531 Lang::Function::~Function( )
1532 {
1533 if( formals_ != 0 )
1534 {
1535 delete formals_->formals_;
1536 delete formals_;
1537 }
1538 }
1539
1540 Kernel::ValueRef
1541 Lang::Function::transformed( const Lang::Transform2D & tf, Kernel::ValueRef self ) const
1542 {
1543 return Kernel::ValueRef( new Lang::TransformedFunction2D( tf, self.down_cast< const Lang::Function >( ) ) );
1544 }
1545
1546 void
1547 Lang::Function::call( Kernel::EvalState * evalState, const Kernel::ValueRef & arg1, const Ast::SourceLocation & callLoc ) const
1548 {
1549 Kernel::Arguments args = this->newCurriedArguments( );
1550
1551 args.addOrderedArgument( Kernel::VariableHandle( new Kernel::Variable( arg1 ) ), & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1552
1553 this->call( evalState, args, callLoc );
1554 }
1555
1556 void
1557 Lang::Function::analyze( Ast::Node * parent, Ast::AnalysisEnvironment * env )
1558 {
1559 Ast::StateIDSet * freeStates = new Ast::StateIDSet;
1560 this->analyze_impl( parent, env, freeStates );
1561 if( ! freeStates->empty( ) )
1562 {
1563 Ast::theAnalysisErrorsList.push_back( new Exceptions::IllegalFreeStates( parent->loc( ), freeStates, "this is a function" ) );
1564 }
1565 else
1566 {
1567 delete freeStates;
1568 }
1569 }
1570
1571 void
1572 Lang::Function::analyze_impl( Ast::Node * parent, Ast::AnalysisEnvironment * env, Ast::StateIDSet * freeStatesDst )
1573 {
1574 throw Exceptions::InternalError( "A syntax function is not overriding the analyze method." );
1575 }
1576
1577 void
1578 Lang::Function::call( Kernel::EvalState * evalState, const Kernel::ValueRef & arg1, const Kernel::ValueRef & arg2, const Ast::SourceLocation & callLoc ) const
1579 {
1580 Kernel::Arguments args = this->newCurriedArguments( );
1581
1582 args.addOrderedArgument( Kernel::VariableHandle( new Kernel::Variable( arg1 ) ), & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1583 args.addOrderedArgument( Kernel::VariableHandle( new Kernel::Variable( arg2 ) ), & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1584
1585 this->call( evalState, args, callLoc );
1586 }
1587
1588 Ast::ArgListExprs * Lang::Function::oneExprArgList = new Ast::ArgListExprs( static_cast< size_t >( 1 ) );
1589 Ast::ArgListExprs * Lang::Function::twoExprsArgList = new Ast::ArgListExprs( static_cast< size_t >( 2 ) );
1590
1591 void
1592 Lang::Function::call( const RefCountPtr< const Lang::Function > & selfRef, Kernel::EvalState * evalState, const Kernel::VariableHandle & arg1, const Ast::SourceLocation & callLoc ) const
1593 {
1594 const RefCountPtr< const Kernel::CallContInfo > info = this->newCallContInfo( Lang::Function::oneExprArgList, *evalState );
1595
1596 if( info->force( 0 ) )
1597 {
1598 Kernel::ContRef cont = Kernel::ContRef( new Kernel::FunctionOneHandleCont( selfRef, evalState->dyn_, evalState->cont_, callLoc ) );
1599 evalState->cont_ = cont;
1600 cont->takeHandle( arg1, evalState );
1601 return;
1602 }
1603
1604 /* The handle need not be forced
1605 */
1606 Kernel::Arguments args = this->newCurriedArguments( );
1607 args.addOrderedArgument( arg1, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1608 this->call( evalState, args, callLoc );
1609 }
1610
1611 void
1612 Lang::Function::call( const RefCountPtr< const Lang::Function > & selfRef, Kernel::EvalState * evalState, const Kernel::VariableHandle & arg1, const Kernel::VariableHandle & arg2, const Ast::SourceLocation & callLoc ) const
1613 {
1614 const RefCountPtr< const Kernel::CallContInfo > info = this->newCallContInfo( Lang::Function::twoExprsArgList, *evalState );
1615
1616 /* Remember that arguments are ordered backwards!
1617 */
1618
1619 if( info->force( 1 ) )
1620 {
1621 Kernel::ContRef cont = Kernel::ContRef( new Kernel::FunctionTwoHandlesCont_1( selfRef, arg2, info->force( 0 ), evalState->dyn_, evalState->cont_, callLoc ) );
1622 evalState->cont_ = cont;
1623 cont->takeHandle( arg1, evalState );
1624 return;
1625 }
1626
1627 if( info->force( 0 ) )
1628 {
1629 Kernel::ContRef cont = Kernel::ContRef( new Kernel::FunctionTwoHandlesCont_2( selfRef, arg1, evalState->dyn_, evalState->cont_, callLoc ) );
1630 evalState->cont_ = cont;
1631 cont->takeHandle( arg2, evalState );
1632 return;
1633 }
1634
1635 /* None of the handles need to be forced
1636 */
1637 Kernel::Arguments args = this->newCurriedArguments( );
1638 args.addOrderedArgument( arg1, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1639 args.addOrderedArgument( arg2, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1640 this->call( evalState, args, callLoc );
1641 }
1642
1643 void
1644 Lang::Function::call( const RefCountPtr< const Lang::Function > & selfRef, Kernel::EvalState * evalState, const Kernel::VariableHandle & arg1, const Kernel::VariableHandle & arg2, Kernel::StateHandle state, const Ast::SourceLocation & callLoc ) const
1645 {
1646 /* I'm not quite sure if we should also put a dummy state argument in info...
1647 */
1648 const RefCountPtr< const Kernel::CallContInfo > info = this->newCallContInfo( Lang::Function::twoExprsArgList, *evalState );
1649
1650 /* Remember that arguments are ordered backwards!
1651 */
1652
1653 if( info->force( 1 ) )
1654 {
1655 Kernel::ContRef cont = Kernel::ContRef( new Kernel::FunctionTwoHandlesOneStateCont_1( selfRef, arg2, info->force( 0 ), state, evalState->dyn_, evalState->cont_, callLoc ) );
1656 evalState->cont_ = cont;
1657 cont->takeHandle( arg1, evalState );
1658 return;
1659 }
1660
1661 if( info->force( 0 ) )
1662 {
1663 Kernel::ContRef cont = Kernel::ContRef( new Kernel::FunctionTwoHandlesOneStateCont_2( selfRef, arg1, state, evalState->dyn_, evalState->cont_, callLoc ) );
1664 evalState->cont_ = cont;
1665 cont->takeHandle( arg2, evalState );
1666 return;
1667 }
1668
1669 /* None of the handles need to be forced
1670 */
1671 Kernel::Arguments args = this->newCurriedArguments( );
1672 args.addOrderedArgument( arg1, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1673 args.addOrderedArgument( arg2, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1674 args.addOrderedState( state, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1675 this->call( evalState, args, callLoc );
1676 }
1677
1678
1679 RefCountPtr< Kernel::CallContInfo >
1680 Lang::Function::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState ) const
1681 {
1682 return formals_->newCallContInfo( argList, evalState );
1683 }
1684
1685 RefCountPtr< Kernel::CallContInfo >
1686 Lang::Function::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, const Kernel::Arguments & curryArgs ) const
1687 {
1688 return formals_->newCallContInfo( argList, evalState, curryArgs );
1689 }
1690
1691 Kernel::Arguments
1692 Lang::Function::newCurriedArguments( ) const
1693 {
1694 return Kernel::Arguments( formals_ );
1695 }
1696
1697
1698 RefCountPtr< const Lang::Class > Lang::Function::TypeID( new Lang::SystemFinalClass( strrefdup( "Function" ) ) );
1699 TYPEINFOIMPL( Function );
1700
1701 Kernel::EvaluatedFormals::EvaluatedFormals( Kernel::Formals * formals )
1702 : selectiveForcing_( false ), forceAll_( false ), formals_( formals ), isSink_( true )
1703 { }
1704
1705 Kernel::EvaluatedFormals::EvaluatedFormals( const Ast::FileID * locationFileID )
1706 : selectiveForcing_( true ), formals_( 0 ), isSink_( true )
1707 {
1708 Kernel::Formals * formals( new Kernel::Formals( ) );
1709 formals->setLoc( Ast::SourceLocation( locationFileID ) );
1710 formals_ = formals;
1711 }
1712
1713 Kernel::EvaluatedFormals::EvaluatedFormals( const Ast::FileID * locationFileID, bool forceAll)
1714 : selectiveForcing_( false ), forceAll_( forceAll ), formals_( 0 ), isSink_( true )
1715 {
1716 Kernel::Formals * formals( new Kernel::Formals( ) );
1717 formals->setLoc( Ast::SourceLocation( locationFileID ) );
1718 formals_ = formals;
1719 }
1720
1721 Kernel::EvaluatedFormals::~EvaluatedFormals( )
1722 {
1723 /* Don't delete the orderedFormals, since we don't own it. A case for reference counting? */
1724 }
1725
1726 RefCountPtr< Kernel::CallContInfo >
1727 Kernel::EvaluatedFormals::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState ) const
1728 {
1729 if( selectiveForcing_ )
1730 {
1731 return RefCountPtr< Kernel::CallContInfo >( new Kernel::CallContInfo( argList, evalState, formals_->newArgListForcePos( argList ) ) );
1732 }
1733 else
1734 {
1735 return RefCountPtr< Kernel::CallContInfo >( new Kernel::CallContInfo( argList, evalState, forceAll_ ) );
1736 }
1737 }
1738
1739 RefCountPtr< Kernel::CallContInfo >
1740 Kernel::EvaluatedFormals::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, const Kernel::Arguments & curryArgs ) const
1741 {
1742 if( selectiveForcing_ )
1743 {
1744 return RefCountPtr< Kernel::CallContInfo >( new Kernel::CallContInfo( argList, evalState, formals_->newArgListForcePos( argList, curryArgs ) ) );
1745 }
1746 else
1747 {
1748 return RefCountPtr< Kernel::CallContInfo >( new Kernel::CallContInfo( argList, evalState, forceAll_ ) );
1749 }
1750 }
1751
1752 void
1753 Kernel::EvaluatedFormals::appendEvaluatedFormal( const char * id, const Kernel::VariableHandle & defaultVal, const Ast::Node * loc, bool force )
1754 {
1755 if( ! selectiveForcing_ )
1756 {
1757 throw Exceptions::InternalError( "EvaluatedFormals::appendEvaluatedFormal: Function does not have selective forcing." );
1758 }
1759 (*(formals_->argumentOrder_))[ id ] = defaults_.size( );
1760 formals_->forcePos_.push_back( force );
1761 defaults_.push_back( defaultVal );
1762 locations_.push_back( loc );
1763 }
1764
1765 void
1766 Kernel::EvaluatedFormals::appendEvaluatedFormal( const char * id, const Kernel::VariableHandle & defaultVal, const Ast::Node * loc )
1767 {
1768 if( selectiveForcing_ )
1769 {
1770 throw Exceptions::InternalError( "EvaluatedFormals::appendEvaluatedFormal: Function requires individual forcing specification." );
1771 }
1772 (*(formals_->argumentOrder_))[ id ] = defaults_.size( );
1773 formals_->forcePos_.push_back( forceAll_ );
1774 defaults_.push_back( defaultVal );
1775 locations_.push_back( loc );
1776 }
1777
1778 void
1779 Kernel::EvaluatedFormals::appendEvaluatedCoreFormal( const char * id, const Kernel::VariableHandle & defaultVal, bool force )
1780 {
1781 appendEvaluatedFormal( id, defaultVal, & Ast::THE_CORE_DEFAULT_VALUE_EXPRESSION, force );
1782 }
1783
1784 void
1785 Kernel::EvaluatedFormals::appendEvaluatedCoreFormal( const char * id, const Kernel::VariableHandle & defaultVal )
1786 {
1787 appendEvaluatedFormal( id, defaultVal, & Ast::THE_CORE_DEFAULT_VALUE_EXPRESSION );
1788 }
1789
1790 void
1791 Kernel::EvaluatedFormals::appendCoreStateFormal( const char * id )
1792 {
1793 (*(formals_->stateOrder_))[ id ] = formals_->stateOrder_->size( );
1794 }
1795
1796 void
1797 Kernel::EvaluatedFormals::gcMark( Kernel::GCMarkedSet & marked )
1798 {
1799 typedef typeof defaults_ ListType;
1800 for( ListType::const_iterator i = defaults_.begin( ); i != defaults_.end( ); ++i )
1801 {
1802 if( *i != NullPtr< Kernel::Variable >( ) )
1803 {
1804 const_cast< Kernel::Variable * >( i->getPtr( ) )->gcMark( marked );
1805 }
1806 }
1807 }
1808
1809
1810 Lang::CuteFunction::CuteFunction( RefCountPtr< const Lang::Function > callee, const Kernel::Arguments & someArgs )
1811 : Lang::Function( 0 ), callee_( callee), someArgs_( someArgs.clone( ) )
1812 { }
1813
1814 Lang::CuteFunction::~CuteFunction( )
1815 { }
1816
1817 RefCountPtr< Kernel::CallContInfo >
1818 Lang::CuteFunction::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState ) const
1819 {
1820 return callee_->newCallContInfo( argList, evalState, someArgs_ );
1821 }
1822
1823 RefCountPtr< Kernel::CallContInfo >
1824 Lang::CuteFunction::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, const Kernel::Arguments & curryArgs ) const
1825 {
1826 /* when we are the callee of a CuteFunction, our someArgs are part of that CuteFunction's someArgs, and hence curryArgs
1827 * contains everything that is to be passed to our callee.
1828 */
1829 return callee_->newCallContInfo( argList, evalState, curryArgs );
1830 }
1831
1832 Kernel::Arguments
1833 Lang::CuteFunction::newCurriedArguments( ) const
1834 {
1835 return someArgs_.clone( );
1836 }
1837
1838 void
1839 Lang::CuteFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1840 {
1841 /* Note that curruying "takes place" in newCurriedArguments. Other than that, this is the same as the original function.
1842 Also note that the total set of arguments being passed to the original function is no more than someArgs and what was passed in the last call.
1843 */
1844 callee_->call( evalState, args, callLoc );
1845 }
1846
1847 bool
1848 Lang::CuteFunction::isTransforming( ) const
1849 {
1850 return callee_->isTransforming( );
1851 }
1852
1853 void
1854 Lang::CuteFunction::gcMark( Kernel::GCMarkedSet & marked )
1855 {
1856 const_cast< Lang::Function * >( callee_.getPtr( ) )->gcMark( marked );
1857 someArgs_.gcMark( marked );
1858 }
1859
1860 void
1861 Lang::CuteFunction::show( std::ostream & os ) const
1862 {
1863 os << "< evaluated cut of: " ;
1864 callee_->show( os );
1865 os << " >" ;
1866 }
1867
1868
1869 Lang::ComposedFunction::ComposedFunction( const RefCountPtr< const Lang::Function > & second, const RefCountPtr< const Lang::Function > & first )
1870 : Lang::Function( 0 ), second_( second ), first_( first )
1871 { }
1872
1873 Lang::ComposedFunction::~ComposedFunction( )
1874 { }
1875
1876 void
1877 Lang::ComposedFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1878 {
1879 /* Note that curruying "takes place" in newCurriedArguments. Other than that, this is the same as the original function.
1880 Also note that the total set of arguments being passed to the original function is no more than someArgs and what was passed in the last call.
1881 */
1882 evalState->cont_ = Kernel::ContRef( new Kernel::ComposedFunctionCall_cont( second_, evalState->dyn_, evalState->cont_, callLoc ) );
1883 first_->call( evalState, args, callLoc );
1884 }
1885
1886 RefCountPtr< Kernel::CallContInfo >
1887 Lang::ComposedFunction::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState ) const
1888 {
1889 return first_->newCallContInfo( argList, evalState );
1890 }
1891
1892 RefCountPtr< Kernel::CallContInfo >
1893 Lang::ComposedFunction::newCallContInfo( const Ast::ArgListExprs * argList, const Kernel::EvalState & evalState, const Kernel::Arguments & curryArgs ) const
1894 {
1895 return first_->newCallContInfo( argList, evalState, curryArgs );
1896 }
1897
1898 Kernel::Arguments
1899 Lang::ComposedFunction::newCurriedArguments( ) const
1900 {
1901 return first_->newCurriedArguments( );
1902 }
1903
1904 bool
1905 Lang::ComposedFunction::isTransforming( ) const
1906 {
1907 return second_->isTransforming( );
1908 }
1909
1910 void
1911 Lang::ComposedFunction::gcMark( Kernel::GCMarkedSet & marked )
1912 {
1913 const_cast< Lang::Function * >( second_.getPtr( ) )->gcMark( marked );
1914 const_cast< Lang::Function * >( first_.getPtr( ) )->gcMark( marked );
1915 }
1916
1917 void
1918 Lang::ComposedFunction::show( std::ostream & os ) const
1919 {
1920 os << "< composition: " ;
1921 second_->show( os );
1922 os << " () " ;
1923 first_->show( os );
1924 os << " >" ;
1925 }
1926
1927
1928 namespace Shapes
1929 {
1930 namespace Kernel
1931 {
1932 class SpanThunks
1933 {
1934 std::vector< Kernel::VariableHandle > thunks_;
1935 public:
1936 SpanThunks( const Kernel::VariableHandle & begin, const Kernel::VariableHandle & end, const Kernel::VariableHandle & step, const Kernel::VariableHandle & count )
1937 {
1938 thunks_.reserve( 4 );
1939 thunks_.push_back( count );
1940 thunks_.push_back( step );
1941 thunks_.push_back( end );
1942 thunks_.push_back( begin );
1943 }
1944 const Kernel::VariableHandle & operator [] ( size_t i ) const
1945 {
1946 return thunks_[ i ];
1947 }
1948 ~SpanThunks( )
1949 { }
1950 void gcMark( Kernel::GCMarkedSet & marked )
1951 {
1952 typedef typeof thunks_ VecType;
1953 for( VecType::iterator i = thunks_.begin( ); i != thunks_.end( ); ++i )
1954 {
1955 (*i)->gcMark( marked );
1956 }
1957 }
1958 };
1959
1960 class SpanForcingContinuation : public Continuation
1961 {
1962 RefCountPtr< const Kernel::SpanThunks > thunks_;
1963 size_t i_;
1964 RefCountPtr< const Lang::SingleList > values_;
1965 RefCountPtr< const Lang::Value > last_;
1966 Kernel::ContRef cont_;
1967 public:
1968 SpanForcingContinuation( const RefCountPtr< const Kernel::SpanThunks > & thunks, size_t i, const RefCountPtr< const Lang::SingleList > & values, const RefCountPtr< const Lang::Value > & last, const Kernel::ContRef & cont, const Ast::SourceLocation & traceLoc )
1969 : Kernel::Continuation( traceLoc ), thunks_( thunks ), i_( i ), values_( values ), last_( last ), cont_( cont )
1970 { }
1971 ~SpanForcingContinuation( )
1972 { }
1973 static void finish( RefCountPtr< const Lang::SingleList > values, RefCountPtr< const Lang::Value > last, Kernel::EvalState * evalState, const Ast::SourceLocation & traceLoc )
1974 {
1975 Kernel::Arguments args = Lang::THE_FUNCTION_RANGE->newCurriedArguments( );
1976 RefCountPtr< const Lang::SingleListPair > src = values.down_cast< const Lang::SingleListPair >( );
1977 args.addOrderedArgument( src->car_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1978 src = src->cdr_.down_cast< const Lang::SingleListPair >( );
1979 args.addOrderedArgument( src->car_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1980 src = src->cdr_.down_cast< const Lang::SingleListPair >( );
1981 args.addOrderedArgument( src->car_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1982 src = src->cdr_.down_cast< const Lang::SingleListPair >( );
1983 args.addOrderedArgument( src->car_, & Ast::THE_INTERNAL_VALUE_EXPRESSION );
1984 Lang::Core_range::makeRange( "<span>", evalState, args, traceLoc, true, last );
1985 }
1986 virtual void takeValue( const RefCountPtr< const Lang::Value > & val, Kernel::EvalState * evalState, bool dummy ) const
1987 {
1988 RefCountPtr< const Lang::SingleList > values = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( val ) ), values_ ) );
1989
1990 for( size_t i = i_ + 1; i < 4; ++i )
1991 {
1992 const Kernel::VariableHandle & var = (*thunks_)[ i ];
1993 if( var->isThunk( ) )
1994 {
1995 evalState->cont_ = Kernel::ContRef( new Kernel::SpanForcingContinuation( thunks_, i, values, last_, cont_, traceLoc_ ) );
1996 var->force( var, evalState );
1997 evalState->dyn_ = Kernel::PassedDyn( new Kernel::DynamicEnvironment( evalState->dyn_, last_ ) );
1998 return;
1999 }
2000 values = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( var, values ) );
2001 }
2002 evalState->cont_ = cont_;
2003 finish( values, last_, evalState, traceLoc_ );
2004 }
2005 virtual Kernel::ContRef up( ) const
2006 {
2007 return cont_;
2008 }
2009 virtual RefCountPtr< const char > description( ) const
2010 {
2011 std::ostringstream msg;
2012 msg << "force span parameter number " << i_ ;
2013 return strrefdup( msg );
2014 }
2015 virtual void gcMark( Kernel::GCMarkedSet & marked )
2016 {
2017 const_cast< Kernel::SpanThunks * >( thunks_.getPtr( ) )->gcMark( marked );
2018 const_cast< Lang::SingleList * >( values_.getPtr( ) )->gcMark( marked );
2019 const_cast< Lang::Value * >( last_.getPtr( ) )->gcMark( marked );
2020 cont_->gcMark( marked );
2021 }
2022 };
2023 }
2024 }
2025
2026 RefCountPtr< const Lang::Class > Lang::Span::TypeID( new Lang::SystemFinalClass( strrefdup( "Span" ) ) );
2027 TYPEINFOIMPL( Span );
2028
2029 Lang::Span::Span( const Kernel::VariableHandle & begin, const Kernel::VariableHandle & end, const Kernel::VariableHandle & step, const Kernel::VariableHandle & count )
2030 : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( "<span>" ), true ) ),
2031 thunks_( new Kernel::SpanThunks( begin, end, step, count ) )
2032 {
2033 formals_->appendEvaluatedCoreFormal( "last", Kernel::THE_SLOT_VARIABLE );
2034 }
2035
2036 Lang::Span::~Span( )
2037 { }
2038
2039 void
2040 Lang::Span::gcMark( Kernel::GCMarkedSet & marked )
2041 {
2042 const_cast< Kernel::SpanThunks * >( thunks_.getPtr( ) )->gcMark( marked );
2043 }
2044
2045 void
2046 Lang::Span::show( std::ostream & os ) const
2047 {
2048 os << "<span>" ;
2049 }
2050
2051 void
2052 Lang::Span::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2053 {
2054 args.applyDefaults( );
2055
2056 RefCountPtr< const Lang::SingleList > values = Lang::THE_CONS_NULL;
2057 for( size_t i = 0; i < 4; ++i )
2058 {
2059 const Kernel::VariableHandle & var = (*thunks_)[ i ];
2060 if( var->isThunk( ) )
2061 {
2062 evalState->cont_ = Kernel::ContRef( new Kernel::SpanForcingContinuation( thunks_, i, values, args.getValue( 0 ), evalState->cont_, callLoc ) );
2063 var->force( var, evalState );
2064 evalState->dyn_ = Kernel::PassedDyn( new Kernel::DynamicEnvironment( evalState->dyn_, args.getValue( 0 ) ) );
2065 return;
2066 }
2067 values = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( var, values ) );
2068 }
2069
2070 /* We only reach this point if there were no thunks at all to be forced. */
2071 Kernel::SpanForcingContinuation::finish( values, args.getValue( 0 ), evalState, callLoc );
2072 }
2073
2074 bool
2075 Lang::Span::isTransforming( ) const
2076 {
2077 return false;
2078 }
2079
2080
2081 Lang::UserFunction::UserFunction( Kernel::EvaluatedFormals * formals, Ast::Expression * body, Kernel::PassedEnv env, const Ast::FunctionMode & functionMode )
2082 : Lang::Function( formals ), body_( body ), env_( env ), functionMode_( functionMode )
2083 { }
2084
2085 // DISPATCHIMPL( UserFunction );
2086
2087 Lang::UserFunction::~UserFunction( )
2088 {
2089 // Note that we don't delete the things that we most likely share with other objects
2090 // Reference counting could be used here, but there will never be more such things than there are function expressions in the source
2091
2092 // This prevents formals->formals from being deleted by Lang::Function::~Function
2093 delete formals_;
2094 formals_ = 0;
2095 }
2096
2097 void
2098 Lang::UserFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2099 {
2100 args.applyDefaults( );
2101 evalState->env_ = new Kernel::Environment( Kernel::theEnvironmentList, env_, formals_->formals_->argumentOrder_, args.getVariables( ), formals_->formals_->stateOrder_, args.getStates( ), "Closure" );
2102 evalState->env_->activateFunctionBoundary( );
2103 evalState->expr_ = body_;
2104 }
2105
2106 bool
2107 Lang::UserFunction::isTransforming( ) const
2108 {
2109 return ( functionMode_ & Ast::FUNCTION_TRANSFORMING ) != 0;
2110 }
2111
2112 void
2113 Lang::UserFunction::gcMark( Kernel::GCMarkedSet & marked )
2114 {
2115 env_->gcMark( marked );
2116 }
2117
2118 Ast::Expression *
2119 Lang::UserFunction::body( )
2120 {
2121 return body_;
2122 }
2123
2124 void
2125 Lang::UserFunction::show( std::ostream & os ) const
2126 {
2127 os << "< user function with body at " << body_->loc( ) << " >" ;
2128 }
2129
2130
2131 Lang::TransformedFunction2D::TransformedFunction2D( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Function > & fun )
2132 : Lang::Function( 0 ), tf_( tf ), fun_( fun )
2133 { }
2134
2135 Lang::TransformedFunction2D::~TransformedFunction2D( )
2136 { }
2137
2138 void
2139 Lang::TransformedFunction2D::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2140 {
2141 evalState->cont_ = Kernel::ContRef( new Kernel::Transform2DCont( tf_, evalState->cont_, 0 ) );
2142 fun_->call( evalState, args, callLoc );
2143 }
2144
2145 bool
2146 Lang::TransformedFunction2D::isTransforming( ) const
2147 {
2148 return fun_->isTransforming( );
2149 }
2150
2151 void
2152 Lang::TransformedFunction2D::gcMark( Kernel::GCMarkedSet & marked )
2153 {
2154 const_cast< Lang::Function * >( fun_.getPtr( ) )->gcMark( marked );
2155 }
2156
2157 void
2158 Lang::TransformedFunction2D::show( std::ostream & os ) const
2159 {
2160 os << "< transformed function >" ;
2161 }
2162
2163
2164
2165 Lang::VectorFunction::VectorFunction( const std::vector< Kernel::ValueRef > * mem )
2166 : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( "<vector>" ), true ) ), mem_( mem ),
2167 memNumeric_( NullPtr< const std::vector< double > >( ) ),
2168 list_( NullPtr< Kernel::Variable >( ) )
2169 {
2170 formals_->appendEvaluatedCoreFormal( "index", Kernel::THE_SLOT_VARIABLE );
2171 }
2172
2173 // DISPATCHIMPL( VectorFunction );
2174
2175 Lang::VectorFunction::~VectorFunction( )
2176 { }
2177
2178 RefCountPtr< const Lang::Class > Lang::VectorFunction::TypeID( new Lang::SystemFinalClass( strrefdup( "VectorFunction" ), Kernel::VectorFunction_register_methods ) );
2179 TYPEINFOIMPL( VectorFunction );
2180
2181 Kernel::VariableHandle
2182 Lang::VectorFunction::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
2183 {
2184 if( strcmp( fieldID, "size" ) == 0 )
2185 {
2186 return Helpers::newValHandle( new Lang::Integer( mem_->size( ) ) );
2187 }
2188 if( strcmp( fieldID, "range" ) == 0 )
2189 {
2190 return Helpers::newValHandle( new Lang::SingleListRange< Lang::Integer >( 0, 1, mem_->size( ) ) );
2191 }
2192 if( strcmp( fieldID, "reverse_range" ) == 0 )
2193 {
2194 return Helpers::newValHandle( new Lang::SingleListRange< Lang::Integer >( mem_->size( ) - 1, -1, mem_->size( ) ) );
2195 }
2196 if( strcmp( fieldID, "list" ) == 0 )
2197 {
2198 compute_list( );
2199 return list_;
2200 }
2201
2202 return TypeID->getMethod( selfRef, fieldID ); /* This will throw if there is no such method. */
2203 }
2204
2205 const char * Lang::VectorFunction::title_ = "<vector>";
2206
2207 void
2208 Lang::VectorFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2209 {
2210 const size_t ARITY = 1;
2211 if( args.size( ) != ARITY )
2212 {
2213 throw Exceptions::CoreArityMismatch( title_, ARITY, args.size( ) );
2214 }
2215
2216 typedef const Lang::Integer ArgType;
2217 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc );
2218
2219 if( arg->val_ < 0 )
2220 {
2221 throw Exceptions::CoreOutOfRange( title_, args, 0, "Index is negative." );
2222 }
2223
2224 if( arg->val_ >= static_cast< int >( mem_->size( ) ) )
2225 {
2226 throw Exceptions::CoreOutOfRange( title_, args, 0, "Index exceeds vector size." );
2227 }
2228
2229 Kernel::ContRef cont = evalState->cont_;
2230 cont->takeValue( (*mem_)[ arg->val_ ],
2231 evalState );
2232 }
2233
2234 bool
2235 Lang::VectorFunction::isTransforming( ) const
2236 {
2237 return false;
2238 }
2239
2240 void
2241 Lang::VectorFunction::gcMark( Kernel::GCMarkedSet & marked )
2242 {
2243 gcMark( mem_, marked );
2244 }
2245
2246 void
2247 Lang::VectorFunction::gcMark( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, Kernel::GCMarkedSet & marked )
2248 {
2249 for( std::vector< Kernel::ValueRef >::const_iterator i = mem->begin( ); i != mem->end( ); ++i )
2250 {
2251 const_cast< Lang::Value * >( i->getPtr( ) )->gcMark( marked );
2252 }
2253 }
2254
2255 void
2256 Lang::VectorFunction::show( std::ostream & os ) const
2257 {
2258 os << "< vector function >" ;
2259 }
2260
2261 RefCountPtr< const std::vector< double > >
2262 Lang::VectorFunction::getNumeric( const Ast::SourceLocation & callLoc ) const
2263 {
2264 if( memNumeric_ == NullPtr< const std::vector< double > >( ) )
2265 {
2266 RefCountPtr< std::vector< double > > res( new std::vector< double > ); // Note that this is not const, so far...
2267 res->reserve( mem_->size( ) );
2268 typedef typeof *mem_ SrcType;
2269 for( SrcType::const_iterator src = mem_->begin( ); src != mem_->end( ); ++src )
2270 {
2271 res->push_back( Helpers::down_cast< const Lang::Float >( *src, callLoc )->val_ );
2272 }
2273
2274 memNumeric_ = res;
2275 }
2276 return memNumeric_;
2277 }
2278
2279 void
2280 Lang::VectorFunction::compute_list( ) const
2281 {
2282 if( list_ != NullPtr< Kernel::Variable >( ) )
2283 {
2284 return;
2285 }
2286 RefCountPtr< const Lang::SingleList > newList = Lang::THE_CONS_NULL;
2287 typedef typeof *mem_ ListType;
2288 for( ListType::const_reverse_iterator src = mem_->rbegin( ); src != mem_->rend( ); ++src )
2289 {
2290 newList = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Kernel::VariableHandle( new Kernel::Variable( *src ) ), newList ) );
2291 }
2292 list_ = Kernel::VariableHandle( new Kernel::Variable( newList ) );
2293 }
2294
2295 namespace Shapes
2296 {
2297 namespace Kernel
2298 {
2299
2300 class VectorFunctionFoldLCont : public Kernel::Continuation
2301 {
2302 RefCountPtr< const std::vector< Kernel::ValueRef > > mem_;
2303 RefCountPtr< const Lang::Function > op_;
2304 Shapes::Lang::VectorFunction::vector_type::const_iterator i_;
2305 Kernel::PassedDyn dyn_;
2306 Kernel::ContRef cont_;
2307 public:
2308 VectorFunctionFoldLCont( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, const RefCountPtr< const Lang::Function > & op, Shapes::Lang::VectorFunction::vector_type::const_iterator i, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
2309 : Kernel::Continuation( traceLoc ), mem_( mem ), op_( op ), i_( i ), dyn_( dyn ), cont_( cont )
2310 { }
2311 virtual ~VectorFunctionFoldLCont( ) { }
2312 virtual void takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
2313 {
2314 evalState->dyn_ = dyn_;
2315 evalState->cont_ = cont_;
2316 Lang::VectorFunction::foldl( mem_, evalState, op_, val, i_, traceLoc_ );
2317 }
2318 virtual Kernel::ContRef up( ) const
2319 {
2320 return cont_;
2321 }
2322 virtual RefCountPtr< const char > description( ) const
2323 {
2324 return strrefdup( "VectorFunction's foldl" );
2325 }
2326 virtual void gcMark( Kernel::GCMarkedSet & marked )
2327 {
2328 Lang::VectorFunction::gcMark( mem_, marked );
2329 const_cast< Lang::Function * >( op_.getPtr( ) )->gcMark( marked );
2330 dyn_->gcMark( marked );
2331 cont_->gcMark( marked );
2332 }
2333 };
2334
2335 class VectorFunctionFoldRCont : public Kernel::Continuation
2336 {
2337 RefCountPtr< const std::vector< Kernel::ValueRef > > mem_;
2338 RefCountPtr< const Lang::Function > op_;
2339 Shapes::Lang::VectorFunction::vector_type::const_reverse_iterator i_;
2340 Kernel::PassedDyn dyn_;
2341 Kernel::ContRef cont_;
2342 public:
2343 VectorFunctionFoldRCont( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, const RefCountPtr< const Lang::Function > & op, Shapes::Lang::VectorFunction::vector_type::const_reverse_iterator i, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
2344 : Kernel::Continuation( traceLoc ), mem_( mem ), op_( op ), i_( i ), dyn_( dyn ), cont_( cont )
2345 { }
2346 virtual ~VectorFunctionFoldRCont( ) { }
2347 virtual void takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
2348 {
2349 evalState->dyn_ = dyn_;
2350 evalState->cont_ = cont_;
2351 Lang::VectorFunction::foldr( mem_, evalState, op_, val, i_, traceLoc_ );
2352 }
2353 virtual Kernel::ContRef up( ) const
2354 {
2355 return cont_;
2356 }
2357 virtual RefCountPtr< const char > description( ) const
2358 {
2359 return strrefdup( "VectorFunction's foldr" );
2360 }
2361 virtual void gcMark( Kernel::GCMarkedSet & marked )
2362 {
2363 Lang::VectorFunction::gcMark( mem_, marked );
2364 const_cast< Lang::Function * >( op_.getPtr( ) )->gcMark( marked );
2365 dyn_->gcMark( marked );
2366 cont_->gcMark( marked );
2367 }
2368 };
2369
2370 class VectorFunctionFoldSLCont : public Kernel::Continuation
2371 {
2372 RefCountPtr< const std::vector< Kernel::ValueRef > > mem_;
2373 RefCountPtr< const Lang::Function > op_;
2374 Shapes::Lang::VectorFunction::vector_type::const_iterator i_;
2375 Kernel::StateHandle state_;
2376 Kernel::PassedDyn dyn_;
2377 Kernel::ContRef cont_;
2378 public:
2379 VectorFunctionFoldSLCont( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, const RefCountPtr< const Lang::Function > & op, Shapes::Lang::VectorFunction::vector_type::const_iterator i, Kernel::StateHandle state, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
2380 : Kernel::Continuation( traceLoc ), mem_( mem ), op_( op ), i_( i ), state_( state ), dyn_( dyn ), cont_( cont )
2381 { }
2382 virtual ~VectorFunctionFoldSLCont( ) { }
2383 virtual void takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
2384 {
2385 evalState->dyn_ = dyn_;
2386 evalState->cont_ = cont_;
2387 Lang::VectorFunction::foldsl( mem_, evalState, op_, val, state_, i_, traceLoc_ );
2388 }
2389 virtual Kernel::ContRef up( ) const
2390 {
2391 return cont_;
2392 }
2393 virtual RefCountPtr< const char > description( ) const
2394 {
2395 return strrefdup( "VectorFunction's foldsl" );
2396 }
2397 virtual void gcMark( Kernel::GCMarkedSet & marked )
2398 {
2399 Lang::VectorFunction::gcMark( mem_, marked );
2400 const_cast< Lang::Function * >( op_.getPtr( ) )->gcMark( marked );
2401 state_->gcMark( marked );
2402 dyn_->gcMark( marked );
2403 cont_->gcMark( marked );
2404 }
2405 };
2406
2407 class VectorFunctionFoldSRCont : public Kernel::Continuation
2408 {
2409 RefCountPtr< const std::vector< Kernel::ValueRef > > mem_;
2410 RefCountPtr< const Lang::Function > op_;
2411 Shapes::Lang::VectorFunction::vector_type::const_reverse_iterator i_;
2412 Kernel::StateHandle state_;
2413 Kernel::PassedDyn dyn_;
2414 Kernel::ContRef cont_;
2415 public:
2416 VectorFunctionFoldSRCont( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, const RefCountPtr< const Lang::Function > & op, Shapes::Lang::VectorFunction::vector_type::const_reverse_iterator i, Kernel::StateHandle state, const Kernel::PassedDyn & dyn, Kernel::ContRef cont, const Ast::SourceLocation & traceLoc )
2417 : Kernel::Continuation( traceLoc ), mem_( mem ), op_( op ), i_( i ), state_( state ), dyn_( dyn ), cont_( cont )
2418 { }
2419 virtual ~VectorFunctionFoldSRCont( ) { }
2420 virtual void takeHandle( Kernel::VariableHandle val, Kernel::EvalState * evalState, bool dummy ) const
2421 {
2422 evalState->dyn_ = dyn_;
2423 evalState->cont_ = cont_;
2424 Lang::VectorFunction::foldsr( mem_, evalState, op_, val, state_, i_, traceLoc_ );
2425 }
2426 virtual Kernel::ContRef up( ) const
2427 {
2428 return cont_;
2429 }
2430 virtual RefCountPtr< const char > description( ) const
2431 {
2432 return strrefdup( "VectorFunction's foldsr" );
2433 }
2434 virtual void gcMark( Kernel::GCMarkedSet & marked )
2435 {
2436 Lang::VectorFunction::gcMark( mem_, marked );
2437 const_cast< Lang::Function * >( op_.getPtr( ) )->gcMark( marked );
2438 state_->gcMark( marked );
2439 dyn_->gcMark( marked );
2440 cont_->gcMark( marked );
2441 }
2442 };
2443
2444 }
2445 }
2446
2447 void
2448 Lang::VectorFunction::foldl( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Function > & op, const Kernel::VariableHandle & nullResult, vector_type::const_iterator i, const Ast::SourceLocation & callLoc )
2449 {
2450 if( i == mem->end( ) )
2451 {
2452 Kernel::ContRef cont = evalState->cont_;
2453 cont->takeHandle( nullResult,
2454 evalState );
2455 return;
2456 }
2457
2458 Kernel::VariableHandle elem = Kernel::VariableHandle( new Kernel::Variable( *i ) );
2459 ++i;
2460 evalState->cont_ = Kernel::ContRef( new Kernel::VectorFunctionFoldLCont( mem, op, i, evalState->dyn_, evalState->cont_, callLoc ) );
2461
2462 op->call( op, evalState, nullResult, elem, callLoc );
2463 }
2464
2465 void
2466 Lang::VectorFunction::foldr( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Function > & op, const Kernel::VariableHandle & nullResult, vector_type::const_reverse_iterator i, const Ast::SourceLocation & callLoc )
2467 {
2468 if( i == mem->rend( ) )
2469 {
2470 Kernel::ContRef cont = evalState->cont_;
2471 cont->takeHandle( nullResult,
2472 evalState );
2473 return;
2474 }
2475
2476 Kernel::VariableHandle elem = Kernel::VariableHandle( new Kernel::Variable( *i ) );
2477 ++i;
2478 evalState->cont_ = Kernel::ContRef( new Kernel::VectorFunctionFoldRCont( mem, op, i, evalState->dyn_, evalState->cont_, callLoc ) );
2479
2480 op->call( op, evalState, nullResult, elem, callLoc );
2481 }
2482
2483 void
2484 Lang::VectorFunction::foldsl( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Function > & op, const Kernel::VariableHandle & nullResult, Kernel::StateHandle state, vector_type::const_iterator i, const Ast::SourceLocation & callLoc )
2485 {
2486 if( i == mem->end( ) )
2487 {
2488 Kernel::ContRef cont = evalState->cont_;
2489 cont->takeHandle( nullResult,
2490 evalState );
2491 return;
2492 }
2493
2494 Kernel::VariableHandle elem = Kernel::VariableHandle( new Kernel::Variable( *i ) );
2495 ++i;
2496 evalState->cont_ = Kernel::ContRef( new Kernel::VectorFunctionFoldSLCont( mem, op, i, state, evalState->dyn_, evalState->cont_, callLoc ) );
2497
2498 op->call( op, evalState, nullResult, elem, state, callLoc );
2499 }
2500
2501 void
2502 Lang::VectorFunction::foldsr( const RefCountPtr< const std::vector< Kernel::ValueRef > > & mem, Kernel::EvalState * evalState, const RefCountPtr< const Lang::Function > & op, const Kernel::VariableHandle & nullResult, Kernel::StateHandle state, vector_type::const_reverse_iterator i, const Ast::SourceLocation & callLoc )
2503 {
2504 if( i == mem->rend( ) )
2505 {
2506 Kernel::ContRef cont = evalState->cont_;
2507 cont->takeHandle( nullResult,
2508 evalState );
2509 return;
2510 }
2511
2512 Kernel::VariableHandle elem = Kernel::VariableHandle( new Kernel::Variable( *i ) );
2513 ++i;
2514 evalState->cont_ = Kernel::ContRef( new Kernel::VectorFunctionFoldSRCont( mem, op, i, state, evalState->dyn_, evalState->cont_, callLoc ) );
2515
2516 op->call( op, evalState, nullResult, elem, state, callLoc );
2517 }
2518
2519
2520 const char * Lang::ColorInterpolator::title_ = "<color-interpolator>";
2521
2522 Lang::ColorInterpolator::ColorInterpolator( const RefCountPtr< KeyContainer > & key,
2523 const RefCountPtr< RGBContainer > & RGBcolor,
2524 const RefCountPtr< GrayContainer > & graycolor,
2525 const RefCountPtr< CMYKContainer > & CMYKcolor,
2526 ColorType colorType)
2527 : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( Lang::ColorInterpolator::title_ ), true ) ),
2528 key_( key ), RGBcolor_ ( RGBcolor ), graycolor_ ( graycolor ), CMYKcolor_ ( CMYKcolor ), colorType_(colorType)
2529 {
2530 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
2531 }
2532
2533 Lang::ColorInterpolator::~ColorInterpolator( )
2534 { }
2535
2536 Kernel::VariableHandle
2537 Lang::ColorInterpolator::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
2538 {
2539 if( strcmp( fieldID, "low" ) == 0 )
2540 {
2541 return Helpers::newValHandle( new Lang::Float( key_->front( ) ) );
2542 }
2543 if( strcmp( fieldID, "high" ) == 0 )
2544 {
2545 return Helpers::newValHandle( new Lang::Float( key_->back( ) ) );
2546 }
2547 throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
2548 }
2549
2550
2551 template <class COLOR_TYPE, class COLOR_CONTAINER>
2552 void
2553 Lang::ColorInterpolator::callHelper( Kernel::EvalState * evalState,
2554 const RefCountPtr< COLOR_CONTAINER > & colorContainer,
2555 double key, KeyContainer::const_iterator keyHi ) const
2556 {
2557 if( keyHi == key_->end( ) )
2558 {
2559 Kernel::ContRef cont = evalState->cont_;
2560 cont->takeValue( RefCountPtr< const::Lang::Value >( new COLOR_TYPE( colorContainer->back( ) ) ),
2561 evalState );
2562 return;
2563 }
2564
2565 if( keyHi == key_->begin( ) )
2566 {
2567 Kernel::ContRef cont = evalState->cont_;
2568 cont->takeValue( RefCountPtr< const::Lang::Value >( new COLOR_TYPE( colorContainer->front( ) ) ),
2569 evalState );
2570 return;
2571 }
2572
2573 KeyContainer::const_iterator keyLo = keyHi - 1;
2574 double rem = ( key - *keyLo ) / ( *keyHi - *keyLo );
2575
2576 Kernel::ContRef cont = evalState->cont_;
2577
2578 typename COLOR_CONTAINER::const_iterator colorHi = colorContainer->begin( ) + ( keyHi - key_->begin( ) );
2579 typename COLOR_CONTAINER::const_iterator colorLo = colorHi - 1;
2580
2581 cont->takeValue( RefCountPtr< const::Lang::Value >( new COLOR_TYPE( colorLo->mulNoCheck( 1 - rem ).addNoCheck( colorHi->mulNoCheck( rem ) ) ) ),
2582 evalState );
2583 }
2584
2585
2586 void
2587 Lang::ColorInterpolator::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2588 {
2589 const size_t ARITY = 1;
2590 if( args.size( ) != ARITY )
2591 {
2592 throw Exceptions::CoreArityMismatch( title_, ARITY, args.size( ) );
2593 }
2594
2595 typedef const Lang::Float ArgType;
2596 double key = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc )->val_;
2597
2598 KeyContainer::const_iterator keyHi = lower_bound( key_->begin( ), key_->end( ), key );
2599 switch( colorType_ )
2600 {
2601 case RGB:
2602 callHelper< Lang::RGB >( evalState, RGBcolor_, key, keyHi );
2603 break;
2604 case GRAY:
2605 callHelper< Lang::Gray >( evalState, graycolor_, key, keyHi );
2606 break;
2607 case CMYK:
2608 callHelper< Lang::CMYK >( evalState, CMYKcolor_, key, keyHi );
2609 break;
2610 case UNDEFINED:
2611 throw Exceptions::InternalError( "ColorInterpolator::call: Did not expect UNDEFINED in ennum switch." );
2612 }
2613 }
2614
2615 bool
2616 Lang::ColorInterpolator::isTransforming( ) const
2617 {
2618 return false;
2619 }
2620
2621 void
2622 Lang::ColorInterpolator::gcMark( Kernel::GCMarkedSet & marked )
2623 { }
2624
2625 void
2626 Lang::ColorInterpolator::show( std::ostream & os ) const
2627 {
2628 os << "< color interpolator in " ;
2629 switch( colorType_ )
2630 {
2631 case RGB:
2632 os << "RGB" ;
2633 break;
2634 case GRAY:
2635 os << "Gray" ;
2636 break;
2637 case CMYK:
2638 os << "CMYK" ;
2639 break;
2640 case UNDEFINED:
2641 throw Exceptions::InternalError( "ColorInterpolator::show: Did not expect UNDEFINED in ennum switch." );
2642 }
2643 os << " mode >" ;
2644 }
2645
2646 Lang::BinaryOperatorFunction::BinaryOperatorFunction( Ast::BinaryInfixExpr * opExpr, const char * title )
2647 : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) ), opExpr_( opExpr ), title_( title )
2648 {
2649 formals_->appendEvaluatedCoreFormal( "first", Kernel::THE_SLOT_VARIABLE );
2650 formals_->appendEvaluatedCoreFormal( "second", Kernel::THE_SLOT_VARIABLE );
2651 }
2652
2653 Lang::BinaryOperatorFunction::~BinaryOperatorFunction( )
2654 {
2655 delete opExpr_;
2656 }
2657
2658 void
2659 Lang::BinaryOperatorFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2660 {
2661 const size_t ARITY = 2;
2662 CHECK_ARITY( args, ARITY, title_ );
2663 RefCountPtr< const Lang::Value > arg1 = args.getValue( 0 );
2664 RefCountPtr< const Lang::Value > arg2 = args.getValue( 1 );
2665
2666 try
2667 {
2668 Kernel::ContRef cont = evalState->cont_;
2669 cont->takeValue( arg1->binaryDispatch1( arg1, arg2, evalState->dyn_, opExpr_ ),
2670 evalState );
2671 }
2672 catch( Exceptions::BinaryInfixNotApplicable & ball )
2673 {
2674 ball.setOperatorSymbol( title_ );
2675 throw;
2676 }
2677 }
2678
2679 bool
2680 Lang::BinaryOperatorFunction::isTransforming( ) const
2681 {
2682 return false;
2683 }
2684
2685 void
2686 Lang::BinaryOperatorFunction::show( std::ostream & os ) const
2687 {
2688 os << "< binary operator function for " << title_ << " >" ;
2689 }
2690
2691
2692 Lang::UnaryOperatorFunction::UnaryOperatorFunction( Ast::UnaryExpr * opExpr, const char * title )
2693 : Lang::Function( new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) ), opExpr_( opExpr ), title_( title )
2694 {
2695 formals_->appendEvaluatedCoreFormal( "only", Kernel::THE_SLOT_VARIABLE );
2696 }
2697
2698 Lang::UnaryOperatorFunction::~UnaryOperatorFunction( )
2699 {
2700 delete opExpr_;
2701 }
2702
2703 void
2704 Lang::UnaryOperatorFunction::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2705 {
2706 const size_t ARITY = 1;
2707 CHECK_ARITY( args, ARITY, title_ );
2708
2709 RefCountPtr< const Lang::Value > arg = args.getValue( 0 );
2710
2711 try
2712 {
2713 Kernel::ContRef cont = evalState->cont_;
2714 cont->takeValue( arg->unaryDispatch( arg, evalState->dyn_, opExpr_ ),
2715 evalState );
2716 }
2717 catch( Exceptions::UnaryPrefixNotApplicable & ball )
2718 {
2719 ball.setOperatorSymbol( title_ );
2720 throw;
2721 }
2722 catch( Exceptions::UnaryPostfixNotApplicable & ball )
2723 {
2724 ball.setOperatorSymbol( title_ );
2725 throw;
2726 }
2727 }
2728
2729 bool
2730 Lang::UnaryOperatorFunction::isTransforming( ) const
2731 {
2732 return false;
2733 }
2734
2735 void
2736 Lang::UnaryOperatorFunction::show( std::ostream & os ) const
2737 {
2738 os << "< unary operator function for " << title_ << " >" ;
2739 }
2740
2741
2742 Lang::Transform2DMethod_chop::Transform2DMethod_chop( RefCountPtr< const Lang::Transform2D > self, const Ast::FileID * fullMethodID )
2743 : Lang::MethodBase< class_type >( self, fullMethodID, false, true )
2744 {
2745 formals_->appendEvaluatedCoreFormal( "L", Kernel::THE_SLOT_VARIABLE );
2746 formals_->appendEvaluatedCoreFormal( "p", Kernel::THE_SLOT_VARIABLE );
2747 }
2748
2749 Lang::Transform2DMethod_chop::~Transform2DMethod_chop( )
2750 { }
2751
2752 void
2753 Lang::Transform2DMethod_chop::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2754 {
2755 args.applyDefaults( );
2756
2757 size_t argsi = 0;
2758 double Ltol = Helpers::down_cast_CoreArgument< const Lang::Float >( title_, args, argsi, callLoc )->val_;
2759 if( Ltol < 0 )
2760 {
2761 throw Exceptions::CoreOutOfRange( title_, args, argsi, "Tolerances must not be negative." );
2762 }
2763
2764 ++argsi;
2765 Concrete::Length ptol = Helpers::down_cast_CoreArgument< const Lang::Length >( title_, args, argsi, callLoc )->get( );
2766 if( ptol < Concrete::ZERO_LENGTH )
2767 {
2768 throw Exceptions::CoreOutOfRange( title_, args, argsi, "Tolerances must not be negative." );
2769 }
2770
2771 Lang::Transform2D * res = self_->clone( );
2772
2773 CHOP_Ltol( res->xx_ );
2774 CHOP_Ltol( res->yx_ );
2775
2776 CHOP_Ltol( res->xy_ );
2777 CHOP_Ltol( res->yy_ );
2778
2779 CHOP_ptol( res->xt_ );
2780 CHOP_ptol( res->yt_ );
2781
2782 Kernel::ContRef cont = evalState->cont_;
2783 cont->takeValue( RefCountPtr< const Lang::Value >( res ),
2784 evalState );
2785 }
2786
2787
2788 Lang::Transform3DMethod_chop::Transform3DMethod_chop( RefCountPtr< const Lang::Transform3D > self, const Ast::FileID * fullMethodID )
2789 : Lang::MethodBase< class_type >( self, fullMethodID, false, true )
2790 {
2791 formals_->appendEvaluatedCoreFormal( "L", Kernel::THE_SLOT_VARIABLE );
2792 formals_->appendEvaluatedCoreFormal( "p", Kernel::THE_SLOT_VARIABLE );
2793 }
2794
2795 Lang::Transform3DMethod_chop::~Transform3DMethod_chop( )
2796 { }
2797
2798 void
2799 Lang::Transform3DMethod_chop::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2800 {
2801 args.applyDefaults( );
2802
2803 size_t argsi = 0;
2804 double Ltol = Helpers::down_cast_CoreArgument< const Lang::Float >( title_, args, argsi, callLoc )->val_;
2805 if( Ltol < 0 )
2806 {
2807 throw Exceptions::CoreOutOfRange( title_, args, argsi, "Tolerances must not be negative." );
2808 }
2809
2810 ++argsi;
2811 Concrete::Length ptol = Helpers::down_cast_CoreArgument< const Lang::Length >( title_, args, argsi, callLoc )->get( );
2812 if( ptol < Concrete::ZERO_LENGTH )
2813 {
2814 throw Exceptions::CoreOutOfRange( title_, args, argsi, "Tolerances must not be negative." );
2815 }
2816
2817 Lang::Transform3D * res = self_->clone( );
2818
2819 CHOP_Ltol( res->xx_ );
2820 CHOP_Ltol( res->yx_ );
2821 CHOP_Ltol( res->zx_ );
2822
2823 CHOP_Ltol( res->xy_ );
2824 CHOP_Ltol( res->yy_ );
2825 CHOP_Ltol( res->zy_ );
2826
2827 CHOP_Ltol( res->xz_ );
2828 CHOP_Ltol( res->yz_ );
2829 CHOP_Ltol( res->zz_ );
2830
2831 CHOP_ptol( res->xt_ );
2832 CHOP_ptol( res->yt_ );
2833 CHOP_ptol( res->zt_ );
2834
2835 Kernel::ContRef cont = evalState->cont_;
2836 cont->takeValue( RefCountPtr< const Lang::Value >( res ),
2837 evalState );
2838 }
Graphics language