?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ammend merge: now compiles
[shapes.git] / source / coreconstruct.cc
blobfcb49fb913aea2f6387e604eb620c156e6ea7495
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, 2009, 2010, 2013, 2014 Henrik Tidefelt
17 */
18
19 #include <cmath>
20
21 #include "Shapes_Helpers_decls.h"
22
23 #include "coreconstruct_impl.h"
24 #include "singlelistrange.h"
25 #include "shapescore.h"
26 #include "globals.h"
27 #include "shapesexceptions.h"
28 #include "consts.h"
29 #include "simplepdfi.h"
30 #include "simplepdfo.h"
31 #include "astfun.h"
32 #include "tagtypes.h"
33 #include "multipage.h"
34 #include "charconverters.h"
35 #include "pagecontentstates.h"
36 #include "texlabelmanager.h"
37 #include "autoonoff.h"
38 #include "timetypes.h"
39 #include "graphtypes.h"
40 #include "shapesscanner.h"
41 #include "rasterloaders.h"
42 #include "glyphlist.h"
43 #include "warn.h"
44 #include "config.h"
45
46 #ifdef HAVE_FT2
47 #include <ft2build.h>
48 #include FT_FREETYPE_H
49 #endif
50 #ifdef HAVE_FONTCONFIG
51 #include <fontconfig/fontconfig.h>
52 #endif
53
54 #include <iostream>
55 #include <sstream>
56 #include <fstream>
57 #include <vector>
58 #include <stdio.h>
59 #include <ctime>
60
61 using namespace Shapes;
62
63
64 namespace Shapes
65 {
66 namespace Helpers
67 {
68 RasterLoader_PNG theRasterLoader_PNG;
69 RasterLoader_JPEG theRasterLoader_JPEG;
70 #ifdef HAVE_FONTCONFIG
71 class AutoDestroyFcPattern
72 {
73 FcPattern * pat_;
74 public:
75 AutoDestroyFcPattern( FcPattern * pat )
76 : pat_( pat )
77 { }
78 ~AutoDestroyFcPattern( )
79 {
80 if( pat_ != 0 )
81 {
82 FcPatternDestroy( pat_ );
83 }
84 }
85 void deactivate( )
86 {
87 pat_ = 0;
88 }
89 };
90 class AutoDestroyFcFontSet
91 {
92 FcFontSet * set_;
93 public:
94 AutoDestroyFcFontSet( FcFontSet * set )
95 : set_( set )
96 { }
97 ~AutoDestroyFcFontSet( )
98 {
99 if( set_ != 0 )
100 {
101 FcFontSetDestroy( set_ );
102 }
103 }
104 void deactivate( )
105 {
106 set_ = 0;
107 }
108 };
109 #endif
110 }
111
112 namespace Lang
113 {
114
115 class Core_tag : public Lang::CoreFunction
116 {
117 public:
118 Core_tag( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
119 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
120 {
121 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
122 formals_->appendEvaluatedCoreFormal( "obj", Kernel::THE_SLOT_VARIABLE );
123 formals_->appendEvaluatedCoreFormal( "transform", Kernel::THE_TRUE_VARIABLE ); /* this argument means "transform if applicable" */
124 formals_->appendEvaluatedCoreFormal( "draw", Kernel::THE_TRUE_VARIABLE ); /* this argument means "draw if applicable" */
125 }
126
127 virtual void
128 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
129 {
130 args.applyDefaults( callLoc );
131
132 typedef const Lang::Symbol KeyType;
133 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( id_, args, 0, callLoc );
134 bool tryTransform = Helpers::down_cast_CoreArgument< const Lang::Boolean >( id_, args, 2, callLoc )->val_;
135 bool tryDraw = Helpers::down_cast_CoreArgument< const Lang::Boolean >( id_, args, 3, callLoc )->val_;
136
137 if( tryDraw && ! tryTransform )
138 {
139 throw Exceptions::CoreOutOfRange( id_, args, 3, "A tagged object which does not transform cannot be drawn." );
140 }
141
142 size_t argsi = 1;
143
144 if( tryDraw )
145 {
146 try
147 {
148 typedef const Lang::Drawable2D ArgType;
149
150 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
151
152 Kernel::ContRef cont = evalState->cont_;
153 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedDrawable2D( key, obj ) ),
154 evalState );
155 return;
156 }
157 catch( const NonLocalExit::NotThisType & ball )
158 {
159 /* Never mind, see below. */
160 }
161
162 try
163 {
164 typedef const Lang::Drawable3D ArgType;
165
166 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
167
168 Kernel::ContRef cont = evalState->cont_;
169 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedDrawable3D( key, obj ) ),
170 evalState );
171 return;
172 }
173 catch( const NonLocalExit::NotThisType & ball )
174 {
175 /* Never mind, see below. */
176 }
177 }
178
179 if( tryTransform )
180 {
181 try
182 {
183 typedef const Lang::Geometric2D ArgType;
184
185 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
186
187 Kernel::ContRef cont = evalState->cont_;
188 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedGeometric2D( key, obj ) ),
189 evalState );
190 return;
191 }
192 catch( const NonLocalExit::NotThisType & ball )
193 {
194 /* Never mind, see below. */
195 }
196
197 try
198 {
199 typedef const Lang::Geometric3D ArgType;
200
201 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
202
203 Kernel::ContRef cont = evalState->cont_;
204 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedGeometric3D( key, obj ) ),
205 evalState );
206 return;
207 }
208 catch( const NonLocalExit::NotThisType & ball )
209 {
210 /* Never mind, see below. */
211 }
212 }
213
214 {
215 // As a last resort, we tag any value.
216 // We return a Drawable2D. Use immerse to make it 3D.
217 Kernel::ContRef cont = evalState->cont_;
218 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedValue2D( key, args.getValue( argsi ) ) ),
219 evalState );
220 }
221 }
222 };
223
224 // This function is in this file just because it i so related to Core_tag.
225 class Core_find : public Lang::CoreFunction
226 {
227 public:
228 Core_find( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
229 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
230 {
231 formals_->appendEvaluatedCoreFormal( "container", Kernel::THE_SLOT_VARIABLE );
232 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
233 }
234
235 virtual void
236 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
237 {
238 args.applyDefaults( callLoc );
239
240 typedef const Lang::Symbol KeyType;
241 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( id_, args, 1, callLoc );
242
243 size_t argsi = 0;
244
245 try
246 {
247 typedef const Lang::Drawable2D ContainerType;
248
249 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
250
251 if( ! container->findOneTag( evalState, key->getKey( ), Lang::THE_2D_IDENTITY ) )
252 {
253 throw Exceptions::CoreOutOfRange( id_, args, 1, "Key not found." );
254 }
255 return;
256 }
257 catch( const NonLocalExit::NotThisType & ball )
258 {
259 /* Never mind, see below. */
260 }
261
262 try
263 {
264 typedef const Lang::Drawable3D ContainerType;
265
266 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
267
268 if( ! container->findOneTag( evalState, key->getKey( ), Lang::THE_3D_IDENTITY ) )
269 {
270 throw Exceptions::CoreOutOfRange( id_, args, 1, "Key not found." );
271 }
272 return;
273 }
274 catch( const NonLocalExit::NotThisType & ball )
275 {
276 /* Never mind, see below. */
277 }
278
279 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, argsi, Helpers::typeSetString( Lang::Drawable2D::staticTypeName( ), Lang::Drawable3D::staticTypeName( ) ) );
280 }
281 };
282
283 // This function is in this file just because it i so related to Core_tag.
284 class Core_findall : public Lang::CoreFunction
285 {
286 public:
287 Core_findall( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
288 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
289 {
290 formals_->appendEvaluatedCoreFormal( "container", Kernel::THE_SLOT_VARIABLE );
291 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
292 }
293
294 virtual void
295 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
296 {
297 args.applyDefaults( callLoc );
298
299 typedef const Lang::Symbol KeyType;
300 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( id_, args, 1, callLoc );
301
302 size_t argsi = 0;
303
304 try
305 {
306 typedef const Lang::Drawable2D ContainerType;
307
308 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
309
310 std::vector< Kernel::ValueRef > * dst = new std::vector< Kernel::ValueRef >;
311 container->findTags( dst, evalState->dyn_, key->getKey( ), Lang::THE_2D_IDENTITY );
312
313 Kernel::ContRef cont = evalState->cont_;
314 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::VectorFunction( dst ) ),
315 evalState );
316 return;
317 }
318 catch( const NonLocalExit::NotThisType & ball )
319 {
320 /* Never mind, see below. */
321 }
322
323 try
324 {
325 typedef const Lang::Drawable3D ContainerType;
326
327 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
328
329 std::vector< Kernel::ValueRef > * dst = new std::vector< Kernel::ValueRef >;
330 container->findTags( dst, evalState->dyn_, key->getKey( ), Lang::THE_3D_IDENTITY );
331
332 Kernel::ContRef cont = evalState->cont_;
333 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::VectorFunction( dst ) ),
334 evalState );
335 return;
336 }
337 catch( const NonLocalExit::NotThisType & ball )
338 {
339 /* Never mind, see below. */
340 }
341
342 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, argsi, Helpers::typeSetString( Lang::Drawable2D::staticTypeName( ), Lang::Drawable3D::staticTypeName( ) ) );
343 }
344 };
345
346 class Core_phong : public Lang::CoreFunction
347 {
348 public:
349 Core_phong( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
350 virtual void
351 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
352 {
353 const size_t ARITY = 1;
354 CHECK_ARITY( args, ARITY, id_ );
355
356 typedef const Lang::Float ArgType;
357 double exponent = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc )->val_;
358 if( exponent < 0 )
359 {
360 throw Exceptions::CoreOutOfRange( id_, args, 0, "The Phong exponent should be greater than 0." );
361 }
362
363 Kernel::ContRef cont = evalState->cont_;
364 cont->takeValue( Kernel::ValueRef( new Lang::SpecularReflectionTerm( 1., exponent ) ),
365 evalState );
366 }
367 };
368
369 class Core_cons : public Lang::CoreFunction
370 {
371 public:
372 Core_cons( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
373 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), false ) )
374 {
375 formals_->appendEvaluatedCoreFormal( "car", Kernel::THE_SLOT_VARIABLE );
376 formals_->appendEvaluatedCoreFormal( "cdr", Kernel::THE_SLOT_VARIABLE );
377 }
378 virtual void
379 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
380 {
381 const size_t ARITY = 2;
382 CHECK_ARITY( args, ARITY, id_ );
383
384 Kernel::VariableHandle cdr = args.getHandle( 1 );
385 if( ! cdr->isThunk( ) ){
386 RefCountPtr< const Lang::Value > cdrVal = cdr->getUntyped( );
387 RefCountPtr< const Lang::SingleList > cdrValTyped = cdrVal.down_cast< const Lang::SingleList >( );
388 if( cdrValTyped != NullPtr< const Lang::SingleList >( ) ){
389 Kernel::ContRef cont = evalState->cont_;
390 cont->takeValue( Kernel::ValueRef( new Lang::SingleListPair( args.getHandle( 0 ),
391 cdrValTyped ) ),
392 evalState );
393 return;
394 }
395 }
396
397 Kernel::ContRef cont = evalState->cont_;
398 cont->takeValue( Kernel::ValueRef( new Lang::ConsPair( args.getHandle( 0 ),
399 cdr ) ),
400 evalState );
401 }
402 };
403
404 class Core_list : public Lang::CoreFunction
405 {
406 public:
407 Core_list( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
408 virtual void
409 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
410 {
411 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
412 if( ! args.empty( ) )
413 {
414 for( size_t i = args.size( ) - 1; ; --i )
415 {
416 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( args.getHandle( i ), res ) );
417 if( i == 0 )
418 {
419 break;
420 }
421 }
422 }
423
424 Kernel::ContRef cont = evalState->cont_;
425 cont->takeValue( res,
426 evalState );
427 }
428 };
429
430 class Core_unlist : public Lang::CoreFunction
431 {
432 Kernel::UnnamedStructureFactory argListFactory_;
433 public:
434 Core_unlist( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
435 virtual void
436 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
437 {
438 const size_t ARITY = 1;
439 CHECK_ARITY( args, ARITY, id_ );
440
441 typedef const Lang::SingleList ArgType;
442
443 Kernel::ContRef cont = evalState->cont_;
444 cont->takeValue( argListFactory_.build( Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc ) ),
445 evalState );
446 }
447 };
448
449 class Core_isnil : public Lang::CoreFunction
450 {
451 public:
452 Core_isnil( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
453 virtual void
454 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
455 {
456 const size_t ARITY = 1;
457 CHECK_ARITY( args, ARITY, id_ );
458
459 RefCountPtr< const Lang::Value > aUntyped = args.getValue( 0 );
460
461 Kernel::ContRef cont = evalState->cont_;
462 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::Boolean( dynamic_cast< const Lang::SingleListNull * >( args.getValue( 0 ).getPtr( ) ) != 0 ) ),
463 evalState );
464 }
465 };
466
467 class Core_span : public Lang::CoreFunction
468 {
469 public:
470 Core_span( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
471 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), false ) )
472 {
473 formals_->appendEvaluatedCoreFormal( "begin", Kernel::THE_VOID_VARIABLE );
474 formals_->appendEvaluatedCoreFormal( "end", Kernel::THE_VOID_VARIABLE );
475 formals_->appendEvaluatedCoreFormal( "step", Kernel::THE_VOID_VARIABLE );
476 formals_->appendEvaluatedCoreFormal( "count", Kernel::THE_VOID_VARIABLE );
477 }
478 virtual void
479 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
480 {
481 args.applyDefaults( callLoc );
482
483 Kernel::ContRef cont = evalState->cont_;
484 cont->takeValue( Kernel::ValueRef( new Lang::Span( args.getHandle( 0 ), args.getHandle( 1 ), args.getHandle( 2 ), args.getHandle( 3 ) ) ),
485 evalState );
486 }
487 };
488
489 class Core_affinetransform : public Lang::CoreFunction
490 {
491 public:
492 Core_affinetransform( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
493 virtual void
494 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
495 {
496 const size_t ARITY = 3;
497 CHECK_ARITY( args, ARITY, id_ );
498
499 typedef const Lang::FloatPair ArgType0;
500 typedef const Lang::FloatPair ArgType1;
501 typedef const Lang::Coords2D ArgType2;
502
503 RefCountPtr< ArgType0 > argx = Helpers::down_cast_CoreArgument< ArgType0 >( id_, args, 0, callLoc );
504 RefCountPtr< ArgType1 > argy = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, 1, callLoc );
505 RefCountPtr< ArgType2 > arg1 = Helpers::down_cast_CoreArgument< ArgType2 >( id_, args, 2, callLoc );
506
507 Kernel::ContRef cont = evalState->cont_;
508 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( argx->x_, argx->y_, argy->x_, argy->y_, arg1->x_.get( ), arg1->y_.get( ) ) ),
509 evalState );
510 }
511 };
512
513 class Core_affinetransform3d : public Lang::CoreFunction
514 {
515 public:
516 Core_affinetransform3d( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
517 virtual void
518 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
519 {
520 const size_t ARITY = 4;
521 CHECK_ARITY( args, ARITY, id_ );
522
523 typedef const Lang::FloatTriple ArgType0;
524 typedef const Lang::FloatTriple ArgType1;
525 typedef const Lang::FloatTriple ArgType2;
526 typedef const Lang::Coords3D ArgType3;
527
528 RefCountPtr< ArgType0 > argx = Helpers::down_cast_CoreArgument< ArgType0 >( id_, args, 0, callLoc );
529 RefCountPtr< ArgType1 > argy = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, 1, callLoc );
530 RefCountPtr< ArgType2 > argz = Helpers::down_cast_CoreArgument< ArgType2 >( id_, args, 2, callLoc );
531 RefCountPtr< ArgType3 > arg1 = Helpers::down_cast_CoreArgument< ArgType3 >( id_, args, 3, callLoc );
532
533 Kernel::ContRef cont = evalState->cont_;
534 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( argx->x_, argx->y_, argx->z_,
535 argy->x_, argy->y_, argy->z_,
536 argz->x_, argz->y_, argz->z_,
537 arg1->x_.get( ), arg1->y_.get( ), arg1->z_.get( ) ) ),
538 evalState );
539 }
540 };
541
542 class Core_shift : public Lang::CoreFunction
543 {
544 public:
545 Core_shift( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
546 virtual void
547 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
548 {
549 const size_t ARITY = 1;
550 CHECK_ARITY( args, ARITY, id_ );
551
552 Kernel::ContRef cont = evalState->cont_;
553
554 size_t i = 0;
555
556 typedef const Lang::Coords2D ArgType1;
557 RefCountPtr< ArgType1 > arg1 = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
558 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( 1, 0, 0, 1, arg1->x_.get( ), arg1->y_.get( ) ) ),
559 evalState );
560 }
561 };
562
563 class Core_shift3d : public Lang::CoreFunction
564 {
565 public:
566 Core_shift3d( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
567 virtual void
568 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
569 {
570 const size_t ARITY = 1;
571 CHECK_ARITY( args, ARITY, id_ );
572
573 Kernel::ContRef cont = evalState->cont_;
574
575 size_t i = 0;
576
577 typedef const Lang::Coords3D ArgType1;
578 RefCountPtr< ArgType1 > arg1 = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
579 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( 1, 0, 0, 0, 1, 0, 0, 0, 1, arg1->x_.get( ), arg1->y_.get( ), arg1->z_.get( ) ) ),
580 evalState );
581 }
582 };
583
584 class Core_rotate : public Lang::CoreFunction
585 {
586 public:
587 Core_rotate( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
588 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
589 {
590 formals_->appendEvaluatedCoreFormal( "angle", Kernel::THE_SLOT_VARIABLE );
591 }
592 virtual void
593 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
594 {
595 args.applyDefaults( callLoc );
596
597 size_t i = 0;
598
599 typedef const Lang::Float ArgType1;
600 RefCountPtr< ArgType1 > arg1 = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
601
602 double c = cos( arg1->val_ );
603 double s = sin( arg1->val_ );
604 Kernel::ContRef cont = evalState->cont_;
605 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( c, s, -s, c, 0, 0 ) ),
606 evalState );
607 }
608 };
609
610 class Core_rotate3d : public Lang::CoreFunction
611 {
612 public:
613 Core_rotate3d( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
614 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
615 {
616 formals_->appendEvaluatedCoreFormal( "dir", Kernel::THE_SLOT_VARIABLE );
617 formals_->appendEvaluatedCoreFormal( "angle", Kernel::THE_SLOT_VARIABLE );
618 }
619 virtual void
620 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
621 {
622 args.applyDefaults( callLoc );
623
624 size_t i = 0;
625
626 typedef const Lang::FloatTriple ArgType1;
627 RefCountPtr< ArgType1 > dir = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
628 if( dir->x_ == 0 && dir->y_ == 0 && dir->z_ == 0 )
629 {
630 throw Exceptions::CoreOutOfRange( id_, args, i, "The rotation direction is degenerate, that is (0,0,0)." );
631 }
632
633 ++i;
634
635 typedef const Lang::Float ArgType2;
636 RefCountPtr< ArgType2 > angle = Helpers::down_cast_CoreArgument< ArgType2 >( id_, args, i, callLoc );
637
638 double r = sqrt( dir->x_ * dir->x_ + dir->y_ * dir->y_ + dir->z_ * dir->z_ );
639 double x = dir->x_ / r;
640 double y = dir->y_ / r;
641 double z = dir->z_ / r;
642 double x2 = x * x;
643 double y2 = y * y;
644 double z2 = z * z;
645 double c = cos( angle->val_ );
646 double s = sin( angle->val_ );
647 Kernel::ContRef cont = evalState->cont_;
648 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( x2+(y2+z2)*c, x*y*(1-c)+z*s, x*z*(1-c)-y*s,
649 x*y*(1-c)-z*s, y2+(x2+z2)*c, y*z*(1-c)+x*s,
650 x*z*(1-c)+y*s, y*z*(1-c)-x*s, z2+(x2+y2)*c,
651 0, 0, 0 ) ),
652 evalState );
653 }
654 };
655
656 class Core_scale : public Lang::CoreFunction
657 {
658 public:
659 Core_scale( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
660 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
661 {
662 Kernel::VariableHandle one( new Kernel::Variable( RefCountPtr< const Lang::Value >( new Lang::Float( 1 ) ) ) );
663
664 formals_->appendEvaluatedCoreFormal( "r", one );
665 formals_->appendEvaluatedCoreFormal( "x", one );
666 formals_->appendEvaluatedCoreFormal( "y", one );
667 }
668 virtual void
669 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
670 {
671 args.applyDefaults( callLoc );
672
673 typedef const Lang::Float ArgType;
674 RefCountPtr< ArgType > argr = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc );
675 RefCountPtr< ArgType > argx = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 1, callLoc );
676 RefCountPtr< ArgType > argy = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 2, callLoc );
677
678 Kernel::ContRef cont = evalState->cont_;
679 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( argr->val_ * argx->val_, 0,
680 0, argr->val_ * argy->val_,
681 0, 0 ) ),
682 evalState );
683 }
684 };
685
686 class Core_scale3d : public Lang::CoreFunction
687 {
688 public:
689 Core_scale3d( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
690 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
691 {
692 Kernel::VariableHandle one( new Kernel::Variable( RefCountPtr< const Lang::Value >( new Lang::Float( 1 ) ) ) );
693
694 formals_->appendEvaluatedCoreFormal( "r", one );
695 formals_->appendEvaluatedCoreFormal( "x", one );
696 formals_->appendEvaluatedCoreFormal( "y", one );
697 formals_->appendEvaluatedCoreFormal( "z", one );
698 }
699 virtual void
700 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
701 {
702 args.applyDefaults( callLoc );
703
704 typedef const Lang::Float ArgType;
705 RefCountPtr< ArgType > argr = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc );
706 RefCountPtr< ArgType > argx = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 1, callLoc );
707 RefCountPtr< ArgType > argy = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 2, callLoc );
708 RefCountPtr< ArgType > argz = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 3, callLoc );
709
710 Kernel::ContRef cont = evalState->cont_;
711 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( argr->val_ * argx->val_, 0, 0,
712 0, argr->val_ * argy->val_, 0,
713 0, 0, argr->val_ * argz->val_,
714 0, 0, 0 ) ),
715 evalState );
716 }
717 };
718
719 class Core_inverse : public Lang::CoreFunction
720 {
721 public:
722 Core_inverse( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
723 virtual void
724 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
725 {
726 const size_t ARITY = 1;
727 CHECK_ARITY( args, ARITY, id_ );
728
729 size_t i = 0;
730
731 typedef const Lang::Transform2D ArgType1;
732 RefCountPtr< ArgType1 > tf = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
733 double det = tf->xx_ * tf->yy_ - tf->xy_ * tf->yx_;
734 if( fabs( det ) < Computation::SINGULAR_TRANSFORM_LIMIT )
735 {
736 throw Exceptions::CoreOutOfRange( id_, args, 0, "Singular transforms cannot be inverted." );
737 }
738 double idet = 1 / det;
739 double ixx = idet * tf->yy_;
740 double ixy = - idet * tf->xy_;
741 double iyx = - idet * tf->yx_;
742 double iyy = idet * tf->xx_;
743 Kernel::ContRef cont = evalState->cont_;
744 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( ixx, iyx,
745 ixy, iyy,
746 -( ixx * tf->xt_ + ixy * tf->yt_ ), -( iyx * tf->xt_ + iyy * tf->yt_ ) ) ),
747 evalState );
748 }
749 };
750
751 class Core_inverse3d : public Lang::CoreFunction
752 {
753 public:
754 Core_inverse3d( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
755 virtual void
756 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
757 {
758 const size_t ARITY = 1;
759 CHECK_ARITY( args, ARITY, id_ );
760
761 size_t i = 0;
762
763 typedef const Lang::Transform3D ArgType1;
764 RefCountPtr< ArgType1 > tf = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, i, callLoc );
765 double det =
766 tf->xx_ * ( tf->yy_ * tf->zz_ - tf->yz_ * tf->zy_ )
767 - tf->xy_ * ( tf->yx_ * tf->zz_ - tf->yz_ * tf->zx_ )
768 + tf->xz_ * ( tf->yx_ * tf->zy_ - tf->yy_ * tf->zx_ );
769 if( fabs( det ) < Computation::SINGULAR_TRANSFORM_LIMIT )
770 {
771 throw Exceptions::CoreOutOfRange( id_, args, 0, "Singular transforms cannot be inverted." );
772 }
773 double idet = 1 / det;
774 double ixx = idet * ( tf->yy_ * tf->zz_ - tf->yz_ * tf->zy_ );
775 double ixy = - idet * ( tf->xy_ * tf->zz_ - tf->xz_ * tf->zy_ );
776 double ixz = idet * ( tf->xy_ * tf->yz_ - tf->xz_ * tf->yy_ );
777 double iyx = - idet * ( tf->yx_ * tf->zz_ - tf->yz_ * tf->zx_ );
778 double iyy = idet * ( tf->xx_ * tf->zz_ - tf->xz_ * tf->zx_ );
779 double iyz = - idet * ( tf->xx_ * tf->yz_ - tf->xz_ * tf->yx_ );
780 double izx = idet * ( tf->yx_ * tf->zy_ - tf->yy_ * tf->zx_ );
781 double izy = - idet * ( tf->xx_ * tf->zy_ - tf->xy_ * tf->zx_ );
782 double izz = idet * ( tf->xx_ * tf->yy_ - tf->xy_ * tf->yx_ );
783 Kernel::ContRef cont = evalState->cont_;
784 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( ixx, iyx, izx,
785 ixy, iyy, izy,
786 ixz, iyz, izz,
787 -( ixx * tf->xt_ + ixy * tf->yt_ + ixz * tf->zt_ ),
788 -( iyx * tf->xt_ + iyy * tf->yt_ + iyz * tf->zt_ ),
789 -( izx * tf->xt_ + izy * tf->yt_ + izz * tf->zt_ ) ) ),
790 evalState );
791 }
792 };
793
794 class Core_formxo : public Lang::CoreFunction
795 {
796 public:
797 Core_formxo( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
798 virtual void
799 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
800 {
801 const size_t ARITY = 1;
802 CHECK_ARITY( args, ARITY, id_ );
803
804 typedef const Lang::Drawable2D ArgType;
805 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc );
806
807 RefCountPtr< const Lang::ElementaryPath2D > theBBox = arg->bbox( Lang::Drawable2D::BOUNDING );
808 Concrete::Coords2D llcorner( 0, 0 );
809 Concrete::Coords2D urcorner( 0, 0 );
810 if( ! theBBox->boundingRectangle( & llcorner, & urcorner ) )
811 {
812 throw Exceptions::InternalErrorIn( id_, "The object has no bounding box." );
813 }
814
815
816 RefCountPtr< SimplePDF::PDF_Stream_out > form;
817 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( form, & Kernel::theIndirectObjectCount );
818
819 RefCountPtr< SimplePDF::PDF_Resources > resources;
820 (*form)[ "Resources" ] = SimplePDF::indirect( resources, & Kernel::theIndirectObjectCount );
821
822 (*form)[ "Subtype" ] = SimplePDF::newName( "Form" );
823 (*form)[ "FormType" ] = SimplePDF::newInt( 1 );
824 (*form)[ "BBox" ] = RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( llcorner.x_.offtype< 1, 0 >( ), llcorner.y_.offtype< 1, 0 >( ),
825 urcorner.x_.offtype< 1, 0 >( ), urcorner.y_.offtype< 1, 0 >( ) ) );
826
827 /* There's a possibility of adding a transformation matrix entry in the dictionary here, but it is not used, not even
828 * for transformed drawables.
829 */
830 // (*markForm)[ "Matrix" ] = RefCountPtr<PDF_Object>( new PDF_Vector( 1, 0, 0, 1, -30, -30 ) );
831
832 Kernel::PageContentStates pdfState( resources );
833 arg->shipout( form->data, & pdfState, Lang::Transform2D( 1, 0, 0, 1, 0, 0 ) );
834
835
836 Lang::XObject * res = new Lang::XObject( indirection,
837 theBBox );
838 res->setDebugStr( "user form" );
839 Kernel::ContRef cont = evalState->cont_;
840 cont->takeValue( Kernel::ValueRef( res ),
841 evalState );
842 }
843 };
844
845 class Core_transparencygroup : public Lang::CoreFunction
846 {
847 public:
848 Core_transparencygroup( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
849 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
850 {
851 formals_->appendEvaluatedCoreFormal( "content", Kernel::THE_SLOT_VARIABLE );
852 formals_->appendEvaluatedCoreFormal( "isolated", Kernel::THE_FALSE_VARIABLE );
853 formals_->appendEvaluatedCoreFormal( "knockout", Kernel::THE_FALSE_VARIABLE );
854 }
855 virtual void
856 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
857 {
858 args.applyDefaults( callLoc );
859
860 typedef const Lang::Group2D ArgType0;
861 typedef const Lang::Boolean ArgType1;
862 typedef const Lang::Boolean ArgType2;
863 RefCountPtr< ArgType0 > content = Helpers::down_cast_CoreArgument< ArgType0 >( id_, args, 0, callLoc );
864 RefCountPtr< ArgType1 > isolated = Helpers::down_cast_CoreArgument< ArgType1 >( id_, args, 1, callLoc );
865 RefCountPtr< ArgType2 > knockout = Helpers::down_cast_CoreArgument< ArgType2 >( id_, args, 2, callLoc );
866
867 RefCountPtr< const Lang::ColorSpace > blendSpace = evalState->dyn_->getBlendSpace( );
868
869 Kernel::ContRef cont = evalState->cont_;
870 cont->takeValue( Helpers::newTransparencyGroup( content, isolated->val_, knockout->val_, blendSpace ),
871 evalState );
872 }
873 };
874
875 class Core_importRasterImage : public Lang::CoreFunction
876 {
877 std::map< const char *, const Helpers::RasterLoader *, charPtrLess > loaders_;
878 public:
879 Core_importRasterImage( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
880 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
881 {
882 formals_->appendEvaluatedCoreFormal( "filename", Kernel::THE_SLOT_VARIABLE );
883 formals_->appendEvaluatedCoreFormal( "resolution", Helpers::newValHandle( new Lang::Length( Concrete::Length( 1 ) ) ) );
884 formals_->appendEvaluatedCoreFormal( "override", Kernel::THE_TRUE_VARIABLE );
885 formals_->appendEvaluatedCoreFormal( "kind", Kernel::THE_VOID_VARIABLE );
886
887 loaders_[ "png" ] = & Helpers::theRasterLoader_PNG;
888 loaders_[ "PNG" ] = & Helpers::theRasterLoader_PNG;
889
890 loaders_[ "jpg" ] = & Helpers::theRasterLoader_JPEG;
891 loaders_[ "JPG" ] = & Helpers::theRasterLoader_JPEG;
892 loaders_[ "jpeg" ] = & Helpers::theRasterLoader_JPEG;
893 loaders_[ "JPEG" ] = & Helpers::theRasterLoader_JPEG;
894
895 /* It would seem natural to also support "JIF"-images, but currently the JPEG library we use won't open such files.
896 */
897 }
898 virtual void
899 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
900 {
901 args.applyDefaults( callLoc );
902
903 size_t argsi = 0;
904
905 typedef const Lang::String ArgType;
906 RefCountPtr< ArgType > filename = Helpers::down_cast_CoreArgument< ArgType >( id_, args, argsi, callLoc );
907 size_t argsi_filename = argsi;
908
909 std::string full_filename;
910 try
911 {
912 full_filename = Ast::theShapesScanner.searchFile( filename->val_.getPtr( ), true ); /* true means that errors should be handled in "runtime mode". */
913 }
914 catch( RefCountPtr< const char > & msg )
915 {
916 throw Exceptions::CoreOutOfRange( id_, args, argsi_filename, msg );
917 }
918
919 RefCountPtr< std::ifstream > iFile( new std::ifstream( full_filename.c_str( ) ) );
920 if( ! iFile->good( ) )
921 {
922 std::ostringstream msg;
923 msg << "Failed to open file for input: " << full_filename.c_str( ) ;
924 throw Exceptions::CoreOutOfRange( id_, args, argsi_filename, strrefdup( msg ) );
925 }
926
927 ++argsi;
928 typedef const Lang::Length ResolutionType;
929 Concrete::Length resolution = Helpers::down_cast_CoreArgument< ResolutionType >( id_, args, argsi, callLoc )->get( );
930 if( resolution <= Concrete::ZERO_LENGTH )
931 {
932 throw Exceptions::CoreOutOfRange( id_, args, argsi, strrefdup( "The resolution must be positive." ) );
933 }
934
935 ++argsi;
936 typedef const Lang::Boolean OverrideType;
937 bool override = Helpers::down_cast_CoreArgument< OverrideType >( id_, args, argsi, callLoc )->val_;
938
939 ++argsi;
940 typedef const Lang::Symbol KindType;
941 RefCountPtr< KindType > kind = Helpers::down_cast_CoreArgument< KindType >( id_, args, argsi, callLoc, true );
942 const Helpers::RasterLoader * loader = 0;
943 if( kind == NullPtr< KindType >( ) )
944 {
945 const char * begin = filename->val_.getPtr( );
946 const char * ext = filename->val_.getPtr( ) + filename->bytecount_ - 1;
947 for( ; ext > begin; --ext )
948 {
949 if( *ext == '.' )
950 {
951 typedef typeof loaders_ MapType;
952 MapType::const_iterator i = loaders_.find( ext + 1 );
953 if( i == loaders_.end( ) )
954 {
955 std::ostringstream msg;
956 msg << "Filename extension '" << ext << "' has no associated raster loader." ;
957 throw Exceptions::CoreOutOfRange( id_, args, argsi_filename, strrefdup( msg ) );
958 }
959 loader = i->second;
960 break;
961 }
962 }
963 if( loader == 0 )
964 {
965 std::ostringstream msg;
966 msg << "Filename without extension must be combined with explicit file kind: " << filename->val_.getPtr( ) ;
967 throw Exceptions::CoreOutOfRange( id_, args, argsi_filename, strrefdup( msg ) );
968 }
969 }
970 else
971 {
972 static Lang::Symbol PNG( "PNG" );
973 static Lang::Symbol JPEG( "JPEG" );
974 if( *kind == PNG )
975 {
976 loader = & Helpers::theRasterLoader_PNG;
977 }
978 else if( *kind == JPEG )
979 {
980 loader = & Helpers::theRasterLoader_JPEG;
981 }
982 else
983 {
984 std::ostringstream msg;
985 msg << "The only allowed file kind symbols are { " ;
986 PNG.show( msg );
987 msg << ", " ;
988 JPEG.show( msg );
989 msg << " }." ;
990 throw Exceptions::CoreOutOfRange( id_, args, argsi, strrefdup( msg ) );
991 }
992 }
993
994 Kernel::ContRef cont = evalState->cont_;
995 cont->takeValue( loader->load( iFile, full_filename, resolution, override, id_, callLoc ),
996 evalState );
997 }
998 };
999
1000 class Core_vector : public Lang::CoreFunction
1001 {
1002 public:
1003 Core_vector( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1004 virtual void
1005 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1006 {
1007 std::vector< RefCountPtr< const Lang::Value > > * res = new std::vector< RefCountPtr< const Lang::Value > >;
1008 res->reserve( args.size( ) );
1009
1010 for( size_t i = 0; i != args.size( ); ++i )
1011 {
1012 res->push_back( args.getValue( i ) );
1013 }
1014
1015 Kernel::ContRef cont = evalState->cont_;
1016 cont->takeValue( Kernel::ValueRef( new Lang::VectorFunction( res ) ),
1017 evalState );
1018 }
1019 };
1020
1021 class Core_graph : public Lang::CoreFunction
1022 {
1023 public:
1024 Core_graph( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1025 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1026 {
1027 formals_->appendEvaluatedCoreFormal( "nodes", Kernel::THE_NIL_VARIABLE );
1028 formals_->appendEvaluatedCoreFormal( "edges", Kernel::THE_NIL_VARIABLE );
1029 formals_->appendEvaluatedCoreFormal( "directed", Kernel::THE_FALSE_VARIABLE );
1030 formals_->appendEvaluatedCoreFormal( "undirected", Kernel::THE_FALSE_VARIABLE );
1031 formals_->appendEvaluatedCoreFormal( "loops", Kernel::THE_FALSE_VARIABLE );
1032 formals_->appendEvaluatedCoreFormal( "parallel", Kernel::THE_FALSE_VARIABLE );
1033 formals_->appendEvaluatedCoreFormal( "partitions", Kernel::THE_VOID_VARIABLE );
1034 }
1035 virtual void
1036 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1037 {
1038 args.applyDefaults( callLoc );
1039
1040 size_t argsi = 0;
1041 size_t nodesi = argsi;
1042 RefCountPtr< const Lang::Value > nodes = args.getValue( argsi );
1043 ++argsi;
1044 size_t edgesi = argsi;
1045 RefCountPtr< const Lang::Value > edges = args.getValue( argsi );
1046
1047 Kernel::GraphDomain * domainPtr = new Kernel::GraphDomain( );
1048 RefCountPtr< const Kernel::GraphDomain > domain = RefCountPtr< const Kernel::GraphDomain >( domainPtr );
1049 typedef const Lang::Boolean FlagType;
1050 ++argsi;
1051 if( Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc )->val_ ){
1052 domainPtr->allowDirected( );
1053 }
1054 ++argsi;
1055 if( Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc )->val_ ){
1056 domainPtr->allowUndirected( );
1057 }
1058 ++argsi;
1059 if( Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc )->val_ ){
1060 domainPtr->allowLoops( );
1061 }
1062 ++argsi;
1063 if( Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc )->val_ ){
1064 domainPtr->allowParallel( );
1065 }
1066
1067 ++argsi;
1068 size_t partitionsi = argsi;
1069 RefCountPtr< const Lang::Value > partitions = args.getValue( argsi );
1070
1071 if( partitions == Lang::THE_VOID ){
1072 RefCountPtr< const Lang::SingleList > noPartitions = RefCountPtr< const Lang::SingleList >( NullPtr< const Lang::SingleList >( ) );
1073 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation
1074 ( Kernel::ContRef( new Kernel::Core_graph_cont_nodes( edges, args.getLoc( edgesi ), domain, noPartitions, evalState->cont_, args.getLoc( partitionsi ), args.getLoc( nodesi ) ) ),
1075 args.getLoc( nodesi ),
1076 true ) );
1077 Kernel::ContRef cont = evalState->cont_;
1078 cont->takeValue( nodes, evalState );
1079 }else{
1080 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation
1081 ( Kernel::ContRef( new Kernel::Core_graph_cont_partitions( nodes, args.getLoc( nodesi ), edges, args.getLoc( edgesi ), domain, evalState->cont_, args.getLoc( partitionsi ) ) ),
1082 args.getLoc( partitionsi ),
1083 true ) );
1084 Kernel::ContRef cont = evalState->cont_;
1085 cont->takeValue( partitions, evalState );
1086 }
1087 }
1088 };
1089
1090 class Core_walk : public Lang::CoreFunction
1091 {
1092 public:
1093 Core_walk( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1094 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1095 {
1096 formals_->appendEvaluatedCoreFormal( "edges", Kernel::THE_NIL_VARIABLE );
1097 formals_->appendEvaluatedCoreFormal( "start", Kernel::THE_VOID_VARIABLE );
1098 formals_->appendEvaluatedCoreFormal( "end", Kernel::THE_VOID_VARIABLE );
1099 }
1100 virtual void
1101 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1102 {
1103 args.applyDefaults( callLoc );
1104
1105 size_t argsi = 0;
1106 typedef const Lang::SingleList ListType;
1107 size_t edgesi = argsi;
1108 RefCountPtr< ListType > edges = Helpers::down_cast_CoreArgument< ListType >( id_, args, argsi, callLoc );
1109
1110 ++argsi;
1111 typedef const Lang::Node NodeType;
1112 /* The start and end may be null pointers, and it is not until the Lang::Graph constructor that
1113 * these will be replaced by automatically determined nodes.
1114 */
1115 RefCountPtr< NodeType > start = Helpers::down_cast_CoreArgument< NodeType >( id_, args, argsi, callLoc, true );
1116
1117 ++argsi;
1118 size_t endi = argsi;
1119 RefCountPtr< NodeType > end = Helpers::down_cast_CoreArgument< NodeType >( id_, args, argsi, callLoc, true );
1120
1121 RefCountPtr< const Lang::Graph > graph = RefCountPtr< const Lang::Graph >( NullPtr< const Lang::Graph >( ) );
1122 if( start != NullPtr< const Lang::Node >( ) ){
1123 graph = start->graph( );
1124 if( end != NullPtr< const Lang::Node >( ) &&
1125 end->graph( ) != graph ){
1126 throw Exceptions::CoreRequirement( "The end node must belong to the same graph as the start node.", id_, args.getLoc( endi ) );
1127 }
1128 }else if( end != NullPtr< const Lang::Node >( ) ){
1129 graph = end->graph( );
1130 }else if( const Lang::SingleListPair * ptr = dynamic_cast< const Lang::SingleListPair * >( edges.getPtr( ) ) ){
1131 RefCountPtr< const Lang::Value > firstEdgeVal = ptr->car_->getUntyped( );
1132 const Lang::Edge * firstEdge = dynamic_cast< const Lang::Edge * >( firstEdgeVal.getPtr( ) );
1133 if( firstEdge == 0 ){
1134 throw Exceptions::TypeMismatch( callLoc, "First edge", firstEdgeVal->getTypeName( ), Lang::Edge::staticTypeName( ) );
1135 }
1136 graph = firstEdge->graph( );
1137 }else{
1138 throw Exceptions::CoreRequirement( "An empty walk must be specified with a start or end node.", id_, callLoc );
1139 }
1140
1141 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation
1142 ( Kernel::ContRef( new Kernel::Core_walk_cont_edges( graph, start, end, args.getLoc( edgesi ), evalState->cont_, callLoc ) ),
1143 args.getLoc( edgesi ),
1144 true ) );
1145 Kernel::ContRef cont = evalState->cont_;
1146 cont->takeValue( edges, evalState );
1147 }
1148 };
1149
1150 class Core_interpolate : public Lang::CoreFunction
1151 {
1152 public:
1153 Core_interpolate( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1154 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1155 {
1156 formals_->appendEvaluatedCoreFormal( "function", Kernel::THE_SLOT_VARIABLE );
1157 formals_->appendEvaluatedCoreFormal( "domain", Kernel::THE_SLOT_VARIABLE );
1158 formals_->appendEvaluatedCoreFormal( "size", Kernel::THE_SLOT_VARIABLE );
1159 formals_->appendEvaluatedCoreFormal( "range", Kernel::THE_SLOT_VARIABLE );
1160 formals_->appendEvaluatedCoreFormal( "encode", Kernel::THE_VOID_VARIABLE );
1161 formals_->appendEvaluatedCoreFormal( "decode", Kernel::THE_VOID_VARIABLE );
1162 }
1163 virtual void
1164 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1165 {
1166 args.applyDefaults( callLoc );
1167
1168 throw Exceptions::NotImplemented( "Core_interpolate::call" );
1169 }
1170 };
1171
1172 class Core_importPDFpages : public Lang::CoreFunction
1173 {
1174 public:
1175 Core_importPDFpages( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1176 virtual void
1177 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1178 {
1179 const size_t ARITY = 1;
1180 CHECK_ARITY( args, ARITY, id_ );
1181
1182 typedef const Lang::String ArgType;
1183 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( id_, args, 0, callLoc );
1184
1185 std::string filename;
1186 try
1187 {
1188 filename = Ast::theShapesScanner.searchFile( arg->val_.getPtr( ), true ); /* true means that errors should be handled in "runtime mode". */
1189 }
1190 catch( RefCountPtr< const char > & msg )
1191 {
1192 throw Exceptions::CoreOutOfRange( id_, args, 0, msg );
1193 }
1194
1195 RefCountPtr< std::ifstream > iFile( new std::ifstream( filename.c_str( ) ) );
1196 if( ! iFile->good( ) )
1197 {
1198 std::ostringstream msg;
1199 msg << "Failed to open file for input: " << arg->val_.getPtr( ) ;
1200 throw Exceptions::CoreOutOfRange( id_, args, 0, strrefdup( msg ) );
1201 }
1202 RefCountPtr< SimplePDF::PDF_in > pdfi( new SimplePDF::PDF_in( iFile ) );
1203
1204 RefCountPtr< const std::vector< RefCountPtr< const Lang::XObject > > > typedRes = RefCountPtr< const std::vector< RefCountPtr< const Lang::XObject > > >( NullPtr< std::vector< RefCountPtr< const Lang::XObject > > >( ) );
1205 try
1206 {
1207 typedRes = Kernel::thePDFImporter.addPagesAsXObjects( pdfi );
1208 }
1209 catch( const char * ball )
1210 {
1211 throw Exceptions::InternalError( strrefdup( ( std::string( "An error occurred while importing " ) + arg->val_.getPtr( ) + ": " + ball ).c_str( ) ) );
1212 }
1213
1214 std::vector< RefCountPtr< const Lang::Value > > * untypedRes = new std::vector< RefCountPtr< const Lang::Value > >;
1215 untypedRes->reserve( typedRes->size( ) );
1216 typedef typeof *typedRes ListType;
1217 for( ListType::const_iterator i = typedRes->begin( ); i != typedRes->end( ); ++i )
1218 {
1219 untypedRes->push_back( *i );
1220 }
1221
1222 Kernel::ContRef cont = evalState->cont_;
1223 cont->takeValue( Kernel::ValueRef( new Lang::VectorFunction( untypedRes ) ),
1224 evalState );
1225 }
1226 };
1227
1228 namespace Implementation
1229 {
1230 double
1231 svg_path_strtod( const char ** src )
1232 {
1233 const char * start = *src;
1234 char * endp;
1235 double res = strtod( start, & endp );
1236 *src = endp;
1237 if( **src != ' ' )
1238 {
1239 for( ; *start == ' '; ++start )
1240 ;
1241 throw std::string( start, strchr( start, ' ' ) - start );
1242 }
1243 return res;
1244 }
1245 }
1246 class Core_svg_path : public Lang::CoreFunction
1247 {
1248 public:
1249 Core_svg_path( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1250 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1251 {
1252 formals_->appendEvaluatedCoreFormal( "d", Kernel::THE_SLOT_VARIABLE );
1253 formals_->appendEvaluatedCoreFormal( "xunit", Helpers::newValHandle( new Lang::Length( Concrete::Length( 1 ) ) ) );
1254 formals_->appendEvaluatedCoreFormal( "yunit", Helpers::newValHandle( new Lang::Length( Concrete::Length( 1 ) ) ) );
1255 formals_->appendEvaluatedCoreFormal( "multi", Kernel::THE_VOID_VARIABLE );
1256 formals_->appendEvaluatedCoreFormal( "singletons", Kernel::THE_TRUE_VARIABLE );
1257 }
1258 virtual void
1259 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1260 {
1261 args.applyDefaults( callLoc );
1262
1263 size_t argsi = 0;
1264 typedef const Lang::String StrType;
1265 RefCountPtr< StrType > arg = Helpers::down_cast_CoreArgument< StrType >( id_, args, argsi, callLoc );
1266
1267 typedef const Lang::Length ScaleType;
1268 ++argsi;
1269 Concrete::Length dx = Helpers::down_cast_CoreArgument< ScaleType >( id_, args, argsi, callLoc )->get( );
1270 ++argsi;
1271 Concrete::Length dy = Helpers::down_cast_CoreArgument< ScaleType >( id_, args, argsi, callLoc )->get( );
1272
1273 typedef const Lang::Boolean FlagType;
1274 ++argsi;
1275 RefCountPtr< FlagType > multi = Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc, true );
1276 ++argsi;
1277 bool singletons = Helpers::down_cast_CoreArgument< FlagType >( id_, args, argsi, callLoc )->val_;
1278
1279 RefCountPtr< char > buf = RefCountPtr< char >( new char[ 2 * strlen( arg->val_.getPtr( ) + 1 ) ] );
1280 {
1281 /* Get rid of any whitespace that isn't a plain space, and make sure every number is terminated by whitespace.
1282 */
1283 char * dst = buf.getPtr( );
1284 for( const char * src = arg->val_.getPtr( ); *src != '\0'; ++src, ++dst )
1285 {
1286 switch( *src )
1287 {
1288 case '\t':
1289 case '\n':
1290 case ',':
1291 *dst = ' ';
1292 continue;
1293 }
1294 if( ( 'A' <= *src && *src <= 'Z' ) || ( 'a' <= *src && *src <= 'z' ) )
1295 {
1296 /* Insert whitespace before command to ensure command is not immediately following number.
1297 */
1298 *dst = ' ';
1299 ++dst;
1300 }
1301 *dst = *src;
1302 }
1303 *dst = ' ';
1304 ++dst;
1305 *dst = '\0';
1306 }
1307
1308 RefCountPtr< Lang::MultiPath2D > multiPath = RefCountPtr< Lang::MultiPath2D >( new Lang::MultiPath2D );
1309 RefCountPtr< Lang::ElementaryPath2D > elemPath = RefCountPtr< Lang::ElementaryPath2D >( NullPtr< Lang::ElementaryPath2D >( ) );
1310
1311 try
1312 {
1313 char cmd = '\0';
1314 Concrete::PathPoint2D originPathPoint( new Concrete::Coords2D( 0, 0 ) );
1315 Concrete::PathPoint2D * first = & originPathPoint;
1316 Concrete::PathPoint2D * last = & originPathPoint;
1317 const char * srcEnd = buf.getPtr( ) + strlen( buf.getPtr( ) );
1318 for( const char * src = buf.getPtr( ); src < srcEnd; ++src )
1319 {
1320 for( ; *src == ' '; ++src )
1321 ;
1322 if( *src == '\0' )
1323 {
1324 break;
1325 }
1326 switch( *src )
1327 {
1328 case 'M':
1329 case 'm':
1330 case 'Z':
1331 case 'z':
1332 case 'L':
1333 case 'l':
1334 case 'H':
1335 case 'h':
1336 case 'V':
1337 case 'v':
1338 case 'C':
1339 case 'c':
1340 case 'S':
1341 case 's':
1342 {
1343 cmd = *src;
1344 ++src;
1345 break;
1346 }
1347 case 'Q':
1348 case 'q':
1349 case 'T':
1350 case 't':
1351 case 'A':
1352 case 'a':
1353 {
1354 throw Exceptions::CoreOutOfRange( id_, args, 0, strrefdup( std::string( "SVG path command not compatible with cubic splines: " ) + *src ) );
1355 }
1356 }
1357 switch( cmd )
1358 {
1359 case 'M':
1360 {
1361 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1362 {
1363 multiPath->push_back( elemPath );
1364 }
1365 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1366 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1367 first = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1368 last = first;
1369 elemPath = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
1370 elemPath->push_back( last );
1371 cmd = 'L';
1372 break;
1373 }
1374 case 'm':
1375 {
1376 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1377 {
1378 multiPath->push_back( elemPath );
1379 }
1380 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1381 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1382 first = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1383 last = first;
1384 elemPath = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
1385 elemPath->push_back( last );
1386 cmd = 'l';
1387 break;
1388 }
1389 case 'Z':
1390 {
1391 elemPath->close( );
1392 last = first;
1393 break;
1394 }
1395 case 'z':
1396 {
1397 elemPath->close( );
1398 last = first;
1399 break;
1400 }
1401 case 'L':
1402 {
1403 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1404 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1405 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1406 elemPath->push_back( last );
1407 break;
1408 }
1409 case 'l':
1410 {
1411 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1412 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1413 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1414 elemPath->push_back( last );
1415 break;
1416 }
1417 case 'H':
1418 {
1419 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1420 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, last->mid_->y_ ) );
1421 elemPath->push_back( last );
1422 break;
1423 }
1424 case 'h':
1425 {
1426 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1427 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, last->mid_->y_ ) );
1428 elemPath->push_back( last );
1429 break;
1430 }
1431 case 'V':
1432 {
1433 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1434 last = new Concrete::PathPoint2D( new Concrete::Coords2D( last->mid_->x_, y ) );
1435 elemPath->push_back( last );
1436 break;
1437 }
1438 case 'v':
1439 {
1440 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1441 last = new Concrete::PathPoint2D( new Concrete::Coords2D( last->mid_->x_, y ) );
1442 elemPath->push_back( last );
1443 break;
1444 }
1445 case 'C':
1446 {
1447 Concrete::Length x1 = dx * Implementation::svg_path_strtod( & src );
1448 Concrete::Length y1 = - dy * Implementation::svg_path_strtod( & src );
1449 Concrete::Length x2 = dx * Implementation::svg_path_strtod( & src );
1450 Concrete::Length y2 = - dy * Implementation::svg_path_strtod( & src );
1451 Concrete::Length x3 = dx * Implementation::svg_path_strtod( & src );
1452 Concrete::Length y3 = - dy * Implementation::svg_path_strtod( & src );
1453 last->front_ = new Concrete::Coords2D( x1, y1 );
1454 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1455 last->rear_ = new Concrete::Coords2D( x2, y2 );
1456 elemPath->push_back( last );
1457 break;
1458 }
1459 case 'c':
1460 {
1461 Concrete::Length x1 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1462 Concrete::Length y1 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1463 Concrete::Length x2 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1464 Concrete::Length y2 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1465 Concrete::Length x3 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1466 Concrete::Length y3 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1467 last->front_ = new Concrete::Coords2D( x1, y1 );
1468 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1469 last->rear_ = new Concrete::Coords2D( x2, y2 );
1470 elemPath->push_back( last );
1471 break;
1472 }
1473 case 'S':
1474 {
1475 Concrete::Length x2 = dx * Implementation::svg_path_strtod( & src );
1476 Concrete::Length y2 = - dy * Implementation::svg_path_strtod( & src );
1477 Concrete::Length x3 = dx * Implementation::svg_path_strtod( & src );
1478 Concrete::Length y3 = - dy * Implementation::svg_path_strtod( & src );
1479 last->front_ = new Concrete::Coords2D( 2 * *(last->mid_) - *(last->rear_) );
1480 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1481 last->rear_ = new Concrete::Coords2D( x2, y2 );
1482 elemPath->push_back( last );
1483 break;
1484 }
1485 case 's':
1486 {
1487 Concrete::Length x2 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1488 Concrete::Length y2 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1489 Concrete::Length x3 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1490 Concrete::Length y3 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1491 last->front_ = new Concrete::Coords2D( 2 * *(last->mid_) - *(last->rear_) );
1492 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1493 last->rear_ = new Concrete::Coords2D( x2, y2 );
1494 elemPath->push_back( last );
1495 break;
1496 }
1497 case '\0':
1498 throw Exceptions::CoreOutOfRange( id_, args, 0, "Malformed SVG path string (failed to initialize command character)." );
1499 default:
1500 {
1501 throw Exceptions::InternalError( "While reading SVG path string: Command character out of range." );
1502 }
1503 }
1504 }
1505 }
1506 catch( const std::string & badNumber )
1507 {
1508 throw Exceptions::CoreOutOfRange( id_, args, 0, strrefdup( std::string( "Ill-formed number: " ) + badNumber ) );
1509 }
1510
1511 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1512 {
1513 multiPath->push_back( RefCountPtr< const Lang::Path2D >( elemPath ) );
1514 }
1515
1516 if( multiPath->size( ) == 0 )
1517 {
1518 throw Exceptions::CoreOutOfRange( id_, args, 0, "No path was produced." );
1519 }
1520 if( multiPath->size( ) == 1 )
1521 {
1522 Kernel::ContRef cont = evalState->cont_;
1523 if( multi != NullPtr< FlagType >( ) && multi->val_ )
1524 {
1525 cont->takeValue( Kernel::ValueRef( multiPath ),
1526 evalState );
1527 }
1528 else
1529 {
1530 cont->takeValue( Kernel::ValueRef( multiPath->front( ) ),
1531 evalState );
1532 }
1533 }
1534 else
1535 {
1536 if( multi != NullPtr< FlagType >( ) && ! multi->val_ )
1537 {
1538 throw Exceptions::CoreOutOfRange( id_, args, 0, "More than one sub-path conflicts with false for <multi>." );
1539 }
1540 Kernel::ContRef cont = evalState->cont_;
1541 cont->takeValue( Kernel::ValueRef( multiPath ),
1542 evalState );
1543 }
1544 }
1545 };
1546
1547 class Core_sprintf : public Lang::CoreFunction
1548 {
1549 public:
1550 Core_sprintf( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1551 virtual void
1552 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1553 {
1554 if( args.empty( ) )
1555 {
1556 throw Exceptions::CoreArityMismatch( id_, 1, args.size( ) );
1557 }
1558 size_t i = 0;
1559 typedef const Lang::String Arg1Type;
1560 RefCountPtr< Arg1Type > arg1 = Helpers::down_cast_CoreArgument< Arg1Type >( id_, args, i, callLoc );
1561
1562 /* snprintf( 0, 0, ... ) does not seem to work properly on some systems.
1563 * Therefore, I resort to the use of a dummy string, and "n = 1".
1564 */
1565 char * res = 0;
1566 int status;
1567 char dummy[1];
1568 switch( args.size( ) )
1569 {
1570 case 1:
1571 {
1572 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), 0 ); /* The final 0 is just a dummy argument that makes the compiler relax. */
1573 res = new char[ sz + 1 ];
1574 status = sprintf( res, arg1->val_.getPtr( ), 0 ); /* The final 0 is just a dummy argument that makes the compiler relax. */
1575 }
1576 break;
1577 case 2:
1578 {
1579 ++i;
1580 {
1581 typedef const Lang::String Arg2Type;
1582 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1583 if( arg2 != 0 )
1584 {
1585 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_.getPtr( ) );
1586 res = new char[ sz + 1 ];
1587 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_.getPtr( ) );
1588 break;
1589 }
1590 }
1591 {
1592 typedef const Lang::Float Arg2Type;
1593 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1594 if( arg2 != 0 )
1595 {
1596 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_ );
1597 res = new char[ sz + 1 ];
1598 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_ );
1599 break;
1600 }
1601 }
1602 {
1603 typedef const Lang::Integer Arg2Type;
1604 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1605 if( arg2 != 0 )
1606 {
1607 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_ );
1608 res = new char[ sz + 1 ];
1609 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_ );
1610 break;
1611 }
1612 }
1613 {
1614 typedef const Lang::ChronologicalTime Arg2Type;
1615 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1616 if( arg2 != 0 )
1617 {
1618 const char * fmt = arg1->val_.getPtr( );
1619 const struct tm * tmp = arg2->temporary_localtime( );
1620 size_t sz = strlen( fmt ) * 2;
1621 res = new char[ sz ];
1622 while( strftime( res, sz, fmt, tmp ) == 0 )
1623 {
1624 delete res;
1625 sz *= 2;
1626 res = new char[ sz ];
1627 }
1628 status = 0; // Here, I'd like to check some error condition instead...
1629 break;
1630 }
1631 }
1632 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, i, Interaction::SEVERAL_TYPES );
1633 }
1634 break;
1635 default:
1636 throw Exceptions::CoreOutOfRange( id_, args, 0, "The number of arguments is out of the implemented range." );
1637 }
1638
1639 if( res == 0 )
1640 {
1641 throw Exceptions::InternalError( "Failed to assign to res in sprintf." );
1642 }
1643
1644 if( status < 0 )
1645 {
1646 std::ostringstream oss;
1647 oss << "Call to library routine returned negative value indicating an error: " << status << ".";
1648 throw Exceptions::CoreOutOfRange( id_, args, 0, strrefdup( oss ) );
1649 }
1650
1651 Kernel::ContRef cont = evalState->cont_;
1652 cont->takeValue( Kernel::ValueRef( new Lang::String( res, false ) ),
1653 evalState );
1654 }
1655 };
1656
1657 class Core_strftime : public Lang::CoreFunction
1658 {
1659 public:
1660 Core_strftime( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1661 virtual void
1662 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1663 {
1664 const size_t ARITY = 0;
1665 CHECK_ARITY( args, ARITY, id_ );
1666
1667 time_t t;
1668 tm * timeInfo;
1669 t = time( 0 );
1670 timeInfo = localtime( & t );
1671 std::ostringstream res;
1672 res << timeInfo->tm_hour << ":" << timeInfo->tm_min << ":" << timeInfo->tm_sec ;
1673
1674 Kernel::ContRef cont = evalState->cont_;
1675 cont->takeValue( Kernel::ValueRef( new Lang::String( strrefdup( res ) ) ),
1676 evalState );
1677 }
1678 };
1679
1680 class Core_ambient_light : public Lang::CoreFunction
1681 {
1682 public:
1683 Core_ambient_light( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1684 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1685 {
1686 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1687 }
1688 virtual void
1689 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1690 {
1691 args.applyDefaults( callLoc );
1692
1693 {
1694 typedef const Lang::Gray ArgType;
1695 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1696 if( col != 0 )
1697 {
1698 Kernel::ContRef cont = evalState->cont_;
1699 cont->takeValue( Kernel::ValueRef( new Lang::AmbientLightGray( col->components( ) ) ),
1700 evalState );
1701 return;
1702 }
1703 }
1704
1705 {
1706 typedef const Lang::RGB ArgType;
1707 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1708 if( col != 0 )
1709 {
1710 Kernel::ContRef cont = evalState->cont_;
1711 cont->takeValue( Kernel::ValueRef( new Lang::AmbientLightRGB( col->components( ) ) ),
1712 evalState );
1713 return;
1714 }
1715 }
1716
1717 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1718 }
1719 };
1720
1721 class Core_specular_light : public Lang::CoreFunction
1722 {
1723 public:
1724 Core_specular_light( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1725 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1726 {
1727 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1728 formals_->appendEvaluatedCoreFormal( "radius", Helpers::newValHandle( new Lang::Length( HUGE_VAL ) ) );
1729 formals_->appendEvaluatedCoreFormal( "shadows", Kernel::THE_FALSE_VARIABLE );
1730 }
1731 virtual void
1732 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1733 {
1734 args.applyDefaults( callLoc );
1735
1736 typedef const Lang::Length RadiusType;
1737 RefCountPtr< RadiusType > radius = Helpers::down_cast_CoreArgument< RadiusType >( id_, args, 1, callLoc );
1738 typedef const Lang::Boolean ShadowsType;
1739 RefCountPtr< ShadowsType > shadows = Helpers::down_cast_CoreArgument< ShadowsType >( id_, args, 2, callLoc );
1740
1741 {
1742 typedef const Lang::Gray ArgType;
1743 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1744 if( col != 0 )
1745 {
1746 Kernel::ContRef cont = evalState->cont_;
1747 cont->takeValue( Kernel::ValueRef( new Lang::SpecularLightGray( Concrete::Coords3D( 0, 0, 0 ),
1748 col->components( ),
1749 radius->get( ),
1750 shadows->val_ ) ),
1751 evalState );
1752 return;
1753 }
1754 }
1755
1756 {
1757 typedef const Lang::RGB ArgType;
1758 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1759 if( col != 0 )
1760 {
1761 Kernel::ContRef cont = evalState->cont_;
1762 cont->takeValue( Kernel::ValueRef( new Lang::SpecularLightRGB( Concrete::Coords3D( 0, 0, 0 ),
1763 col->components( ),
1764 radius->get( ),
1765 shadows->val_ ) ),
1766 evalState );
1767 return;
1768 }
1769 }
1770
1771 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1772 }
1773 };
1774
1775 class Core_distant_light : public Lang::CoreFunction
1776 {
1777 public:
1778 Core_distant_light( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1779 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1780 {
1781 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1782 formals_->appendEvaluatedCoreFormal( "shadows", Kernel::THE_FALSE_VARIABLE );
1783 }
1784 virtual void
1785 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1786 {
1787 args.applyDefaults( callLoc );
1788
1789 typedef const Lang::Boolean ShadowsType;
1790 RefCountPtr< ShadowsType > shadows = Helpers::down_cast_CoreArgument< ShadowsType >( id_, args, 1, callLoc );
1791
1792 {
1793 typedef const Lang::Gray ArgType;
1794 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1795 if( col != 0 )
1796 {
1797 Kernel::ContRef cont = evalState->cont_;
1798 cont->takeValue( Kernel::ValueRef( new Lang::DistantLightGray( Concrete::UnitFloatTriple( 0., 0., -1. ),
1799 col->components( ),
1800 shadows->val_ ) ),
1801 evalState );
1802 return;
1803 }
1804 }
1805
1806 {
1807 typedef const Lang::RGB ArgType;
1808 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1809 if( col != 0 )
1810 {
1811 Kernel::ContRef cont = evalState->cont_;
1812 cont->takeValue( Kernel::ValueRef( new Lang::DistantLightRGB( Concrete::UnitFloatTriple( 0., 0., -1. ),
1813 col->components( ),
1814 shadows->val_ ) ),
1815 evalState );
1816 return;
1817 }
1818 }
1819
1820 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1821 }
1822 };
1823
1824 class Core_textrenderingmode : public Lang::CoreFunction
1825 {
1826 public:
1827 Core_textrenderingmode( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
1828 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1829 {
1830 formals_->appendEvaluatedCoreFormal( "fill", Kernel::THE_FALSE_VARIABLE );
1831 formals_->appendEvaluatedCoreFormal( "stroke", Kernel::THE_FALSE_VARIABLE );
1832 }
1833 virtual void
1834 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1835 {
1836 args.applyDefaults( callLoc );
1837
1838 typedef const Lang::Boolean FlagType;
1839 RefCountPtr< FlagType > fill = Helpers::down_cast_CoreArgument< FlagType >( id_, args, 0, callLoc );
1840 RefCountPtr< FlagType > stroke = Helpers::down_cast_CoreArgument< FlagType >( id_, args, 1, callLoc );
1841
1842 Kernel::ContRef cont = evalState->cont_;
1843 cont->takeValue( Kernel::ValueRef( new Lang::TextRenderingMode( fill->val_, stroke->val_, false ) ),
1844 evalState );
1845 }
1846 };
1847
1848 class Core_manualkern : public Lang::CoreFunction
1849 {
1850 public:
1851 Core_manualkern( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1852 virtual void
1853 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1854 {
1855 // Note that res is _not_ yet const. We use a RefCountPtr to take care of memory deallocation in case some argument has the wrong type and
1856 // the result is not used.
1857 RefCountPtr< Lang::KernedText > res( new Lang::KernedText( evalState->dyn_->getTextState( ), evalState->dyn_->getGraphicsState( ) ) );
1858
1859 for( size_t i = 0; i != args.size( ); ++i )
1860 {
1861 try
1862 {
1863 typedef const Lang::String ArgType;
1864 res->pushString( Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) ) );
1865 continue;
1866 }
1867 catch( const NonLocalExit::NotThisType & ball )
1868 {
1869 /* Never mind, see below. */
1870 }
1871
1872 try
1873 {
1874 typedef const Lang::Float ArgType;
1875 res->pushKerning( Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->val_ );
1876 continue;
1877 }
1878 catch( const NonLocalExit::NotThisType & ball )
1879 {
1880 /* Never mind, see below. */
1881 }
1882
1883 try
1884 {
1885 typedef const Lang::KernedText ArgType;
1886 Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->push( res.getPtr( ) );
1887 continue;
1888 }
1889 catch( const NonLocalExit::NotThisType & ball )
1890 {
1891 /* Never mind, see below. */
1892 }
1893
1894 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, i, Helpers::typeSetString( Lang::String::staticTypeName( ), Lang::Float::staticTypeName( ), Lang::KernedText::staticTypeName( ) ) );
1895 }
1896
1897 Kernel::ContRef cont = evalState->cont_;
1898 cont->takeValue( res,
1899 evalState );
1900 }
1901 };
1902
1903 class Core_automatickern : public Lang::CoreFunction
1904 {
1905 public:
1906 Core_automatickern( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name ) : CoreFunction( ns, name ) { }
1907 virtual void
1908 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1909 {
1910 iconv_t converter = Helpers::requireUTF8ToUCS4Converter( );
1911 iconv_t backconverter = Helpers::requireUCS4ToUTF8Converter( );
1912
1913 RefCountPtr< const FontMetrics::FontMetric > metrics = evalState->dyn_->getTextState( )->font_->metrics( );
1914 if( metrics->horizontalMetrics_ == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
1915 {
1916 throw Exceptions::FontMetricsError( evalState->dyn_->getTextState( )->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
1917 }
1918
1919 // Note that res is _not_ yet const. We use a RefCountPtr to take care of memory deallocation in case some argument has the wrong type and
1920 // the result is not used.
1921 RefCountPtr< Lang::KernedText > res( new Lang::KernedText( evalState->dyn_->getTextState( ), evalState->dyn_->getGraphicsState( ) ) );
1922
1923 std::ostringstream pendingChars;
1924 Kernel::UnicodeCodePoint prevChar( 0 );
1925 double pendingKerning = 0;
1926
1927 const size_t backbufSize = 5;
1928 char backbuf[ backbufSize ];
1929
1930 for( size_t i = 0; i != args.size( ); ++i )
1931 {
1932 try
1933 {
1934 typedef const Lang::String ArgType;
1935 RefCountPtr< ArgType > str = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) );
1936
1937 const char * inbuf = str->val_.getPtr( );
1938 size_t inbytesleft = strlen( inbuf );
1939
1940 size_t bufSize = 4 * inbytesleft;
1941 char * buf = new char[ bufSize ];
1942 DeleteOnExit< char > bufDeleter( buf );
1943
1944 char * outbuf = buf;
1945 size_t outbytesleft = bufSize;
1946 // The ICONV_CAST macro is defined in config.h.
1947 size_t count = iconv( converter,
1948 ICONV_CAST( & inbuf ), & inbytesleft,
1949 & outbuf, & outbytesleft );
1950 if( count == (size_t)(-1) )
1951 {
1952 if( errno == EILSEQ )
1953 {
1954 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no UCS-4 representation." );
1955 }
1956 else if( errno == EINVAL )
1957 {
1958 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
1959 }
1960 else if( errno == E2BIG )
1961 {
1962 throw Exceptions::InternalError( "Core_automatickern: The buffer allocated for UTF-8 to UCS-4 conversion was too small." );
1963 }
1964 else
1965 {
1966 std::ostringstream msg;
1967 msg << "iconv failed with an unrecognized error code: " << errno ;
1968 throw Exceptions::InternalError( strrefdup( msg ) );
1969 }
1970 }
1971 for( const char * src = buf; src != outbuf; src += 4 )
1972 {
1973 Kernel::UnicodeCodePoint currentChar;
1974 currentChar.decode_UCS4( src );
1975 double currentKerning = pendingKerning - metrics->getHorizontalKernPairXByCode( prevChar, currentChar );
1976 prevChar = currentChar;
1977 pendingKerning = 0;
1978 if( currentKerning != 0 )
1979 {
1980 if( ! pendingChars.str( ).empty( ) )
1981 {
1982 res->pushString( RefCountPtr< const Lang::String >( new Lang::String( strrefdup( pendingChars ) ) ) );
1983 pendingChars.str( "" );
1984 }
1985 res->pushKerning( currentKerning );
1986 }
1987
1988 // Copy the current (multibyte) character to the character queue
1989 {
1990 const char * inbuf = src;
1991 char * outbuf = backbuf;
1992 size_t inbytesleft = 4;
1993 size_t outbytesleft = backbufSize;
1994 // The ICONV_CAST macro is defined in config.h.
1995 size_t count = iconv( backconverter,
1996 ICONV_CAST( & inbuf ), & inbytesleft,
1997 & outbuf, & outbytesleft );
1998 if( count == (size_t)(-1) )
1999 {
2000 if( errno == EILSEQ )
2001 {
2002 throw Exceptions::ExternalError( "A character converted from UTF-8 could not be converted back to UFT-8." );
2003 }
2004 else if( errno == EINVAL )
2005 {
2006 throw Exceptions::ExternalError( "A character converted from UTF-8 was deemed incomplete." );
2007 }
2008 else if( errno == E2BIG )
2009 {
2010 throw Exceptions::InternalError( "The buffer allocated for conversion of a single character back to UTF-8 was too small." );
2011 }
2012 else
2013 {
2014 std::ostringstream msg;
2015 msg << "iconv failed with an unrecognized error code: " << errno ;
2016 throw Exceptions::InternalError( strrefdup( msg ) );
2017 }
2018 }
2019 *outbuf = '\0';
2020 pendingChars << backbuf ;
2021 }
2022 }
2023 continue;
2024 }
2025 catch( const NonLocalExit::NotThisType & ball )
2026 {
2027 /* Never mind, see below. */
2028 }
2029
2030 try
2031 {
2032 typedef const Lang::Float ArgType;
2033 pendingKerning += Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->val_;
2034 continue;
2035 }
2036 catch( const NonLocalExit::NotThisType & ball )
2037 {
2038 /* Never mind, see below. */
2039 }
2040
2041 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, i, Helpers::typeSetString( Lang::String::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2042 }
2043
2044 if( ! pendingChars.str( ).empty( ) )
2045 {
2046 res->pushString( RefCountPtr< const Lang::String >( new Lang::String( strrefdup( pendingChars ) ) ) );
2047 pendingChars.str( "" );
2048 }
2049
2050 Kernel::ContRef cont = evalState->cont_;
2051 cont->takeValue( res,
2052 evalState );
2053 }
2054 };
2055
2056 class Core_newrandom : public Lang::CoreFunction
2057 {
2058 public:
2059 Core_newrandom( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2060 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
2061 {
2062 formals_->appendEvaluatedCoreFormal( "seed", Kernel::THE_SLOT_VARIABLE );
2063 formals_->appendEvaluatedCoreFormal( "size", Helpers::newValHandle( new Lang::Integer( 32 ) ) );
2064 }
2065 virtual void
2066 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2067 {
2068 args.applyDefaults( callLoc );
2069
2070 typedef const Lang::Integer SizeType;
2071 Lang::Integer::ValueType sz = Helpers::down_cast_CoreArgument< SizeType >( id_, args, 1, callLoc )->val_;
2072 if( sz < 8 )
2073 {
2074 throw Exceptions::CoreOutOfRange( id_, args, 1, "The size must be at least 8." );
2075 }
2076 if( sz > 256 )
2077 {
2078 throw Exceptions::CoreOutOfRange( id_, args, 1, "The size must at most 256." );
2079 }
2080
2081 size_t argsi = 0;
2082
2083 try
2084 {
2085 typedef const Lang::ChronologicalTime SeedType;
2086
2087 RefCountPtr< SeedType > seed = Helpers::try_cast_CoreArgument< SeedType >( args.getValue( argsi ) );
2088
2089 Kernel::ContRef cont = evalState->cont_;
2090 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( sz, seed->val( ) ) ),
2091 evalState );
2092 return;
2093 }
2094 catch( const NonLocalExit::NotThisType & ball )
2095 {
2096 /* Never mind, see below. */
2097 }
2098
2099 try
2100 {
2101 typedef const Lang::Integer SeedType;
2102
2103 RefCountPtr< SeedType > seed = Helpers::try_cast_CoreArgument< SeedType >( args.getValue( argsi ) );
2104
2105 Kernel::ContRef cont = evalState->cont_;
2106 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( sz, seed->val_ ) ),
2107 evalState );
2108 return;
2109 }
2110 catch( const NonLocalExit::NotThisType & ball )
2111 {
2112 /* Never mind, see below. */
2113 }
2114
2115 throw Exceptions::CoreTypeMismatch( callLoc, id_, args, argsi, Helpers::typeSetString( Lang::Integer::staticTypeName( ), Lang::ChronologicalTime::staticTypeName( ) ) );
2116 }
2117 };
2118
2119 class Core_devrandom : public Lang::CoreFunction
2120 {
2121 public:
2122 Core_devrandom( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2123 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
2124 {
2125 formals_->appendCoreStateFormal( "device" );
2126 formals_->appendEvaluatedCoreFormal( "size", Helpers::newValHandle( new Lang::Integer( 32 ) ) );
2127 }
2128 virtual void
2129 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2130 {
2131 args.applyDefaults( callLoc );
2132
2133 typedef const Lang::Integer SizeType;
2134 Lang::Integer::ValueType sz = Helpers::down_cast_CoreArgument< SizeType >( id_, args, 0, callLoc )->val_;
2135 if( sz < 8 )
2136 {
2137 throw Exceptions::CoreOutOfRange( id_, args, 0, "The size must be at least 8." );
2138 }
2139 if( sz > 256 )
2140 {
2141 throw Exceptions::CoreOutOfRange( id_, args, 0, "The size must at most 256." );
2142 }
2143
2144 typedef Kernel::WarmRandomDevice GeneratorType;
2145 GeneratorType * gen = Helpers::down_cast_CoreState< GeneratorType >( id_, args, 0, callLoc );
2146
2147 Kernel::ContRef cont = evalState->cont_;
2148 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( static_cast< size_t >( sz ), gen ) ),
2149 evalState );
2150 }
2151 };
2152
2153 class Core_destination : public Lang::CoreFunction
2154 {
2155 public:
2156 Core_destination( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2157 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
2158 {
2159 formals_->appendEvaluatedCoreFormal( "remote", Kernel::THE_FALSE_VARIABLE );
2160 formals_->appendEvaluatedCoreFormal( "name", Kernel::THE_VOID_VARIABLE );
2161 formals_->appendEvaluatedCoreFormal( "level", Kernel::THE_VOID_VARIABLE );
2162 formals_->appendEvaluatedCoreFormal( "text", Kernel::THE_VOID_VARIABLE );
2163 formals_->appendEvaluatedCoreFormal( "open", Kernel::THE_FALSE_VARIABLE );
2164 formals_->appendEvaluatedCoreFormal( "bold", Kernel::THE_FALSE_VARIABLE );
2165 formals_->appendEvaluatedCoreFormal( "italic", Kernel::THE_FALSE_VARIABLE );
2166 formals_->appendEvaluatedCoreFormal( "color", Helpers::newValHandle( new Lang::RGB( Concrete::RGB( 0, 0, 0 ) ) ) );
2167 formals_->appendEvaluatedCoreFormal( "sides", Kernel::THE_VOID_VARIABLE );
2168 formals_->appendEvaluatedCoreFormal( "target", Kernel::THE_VOID_VARIABLE );
2169 formals_->appendEvaluatedCoreFormal( "fittobbox", Kernel::THE_VOID_VARIABLE );
2170 formals_->appendEvaluatedCoreFormal( "zoom", Kernel::THE_VOID_VARIABLE );
2171 formals_->appendEvaluatedCoreFormal( "transform", Kernel::THE_TRUE_VARIABLE );
2172 }
2173 virtual void
2174 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2175 {
2176 args.applyDefaults( callLoc );
2177
2178 size_t argsi = 0;
2179 const size_t remove_i = argsi;
2180 typedef const Lang::Boolean RemoteType;
2181 bool remote = Helpers::down_cast_CoreArgument< RemoteType >( id_, args, argsi, callLoc )->val_;
2182
2183 ++argsi;
2184 typedef const Lang::String NameType;
2185 RefCountPtr< NameType > nameVal = Helpers::down_cast_CoreArgument< NameType >( id_, args, argsi, callLoc, true );
2186 RefCountPtr< const char > name = RefCountPtr< const char >( NullPtr< const char >( ) );
2187 if( nameVal != NullPtr< NameType >( ) )
2188 {
2189 const SimplePDF::PDF_Version::Version STRINGDESTS_VERSION = SimplePDF::PDF_Version::PDF_1_2;
2190 if( Kernel::the_PDF_version.greaterOrEqual( STRINGDESTS_VERSION ) )
2191 {
2192 name = nameVal->val_;
2193 }
2194 else
2195 {
2196 Kernel::the_PDF_version.message( STRINGDESTS_VERSION, "The naming of a destination was ignored." );
2197 // Note that this will leave name being null, and hence generate further errors if remote_.
2198 }
2199 }
2200 if( nameVal == NullPtr< NameType >( ) ) // Note why this is not an else clause!
2201 {
2202 if( remote )
2203 {
2204 throw Exceptions::CoreOutOfRange( id_, args, remove_i, "The destination cannot be remote if no name is given." );
2205 }
2206 }
2207
2208 ++argsi;
2209 const size_t outlineLevel_i = argsi;
2210 typedef const Lang::Integer OutlineLevelType;
2211 RefCountPtr< OutlineLevelType > levelVal = Helpers::down_cast_CoreArgument< OutlineLevelType >( id_, args, argsi, callLoc, true );
2212 int outlineLevel = -1; // This will remain negative only if the level is not present.
2213 if( levelVal != NullPtr< OutlineLevelType >( ) )
2214 {
2215 outlineLevel = levelVal->val_;
2216 if( outlineLevel < 0 )
2217 {
2218 throw Exceptions::CoreOutOfRange( id_, args, argsi, "The outline level must be non-negative." );
2219 }
2220 }
2221
2222 ++argsi;
2223 typedef const Lang::String OutlineTextType;
2224 RefCountPtr< OutlineTextType > textVal = Helpers::down_cast_CoreArgument< OutlineTextType >( id_, args, argsi, callLoc, true );
2225 RefCountPtr< const char > outlineText = RefCountPtr< const char >( NullPtr< const char >( ) );
2226 if( textVal != NullPtr< OutlineTextType >( ) )
2227 {
2228 outlineText = textVal->val_;
2229 }
2230 else
2231 {
2232 if( outlineLevel >= 0 )
2233 {
2234 throw Exceptions::CoreOutOfRange( id_, args, outlineLevel_i, "Without an outline text, it is not allowed to make an outline item." );
2235 }
2236 }
2237
2238 ++argsi;
2239 typedef const Lang::Boolean OutlineOpenType;
2240 bool outlineOpen = Helpers::down_cast_CoreArgument< OutlineOpenType >( id_, args, argsi, callLoc )->val_;
2241
2242 ++argsi;
2243 typedef const Lang::Boolean OutlineBoldType;
2244 bool outlineBold = Helpers::down_cast_CoreArgument< OutlineBoldType >( id_, args, argsi, callLoc )->val_;
2245
2246 ++argsi;
2247 typedef const Lang::Boolean OutlineItalicType;
2248 bool outlineItalic = Helpers::down_cast_CoreArgument< OutlineItalicType >( id_, args, argsi, callLoc )->val_;
2249
2250 ++argsi;
2251 typedef const Lang::RGB OutlineColorType;
2252 Concrete::RGB outlineColor = Helpers::down_cast_CoreArgument< OutlineColorType >( id_, args, argsi, callLoc )->components( );
2253
2254 ++argsi;
2255 const size_t sidesMode_i = argsi;
2256 typedef const Lang::Symbol SidesModeType;
2257 RefCountPtr< SidesModeType > sidesVal = Helpers::down_cast_CoreArgument< SidesModeType >( id_, args, argsi, callLoc, true );
2258
2259 ++argsi;
2260 const size_t target_i = argsi;
2261 typedef const Lang::Drawable2D TargetType;
2262 RefCountPtr< TargetType > target = Helpers::down_cast_CoreArgument< TargetType >( id_, args, argsi, callLoc, true );
2263
2264 Lang::DocumentDestination::Sides sides = Lang::DocumentDestination::PAGE; // Defaults to false, unless a target is given.
2265 if( target != NullPtr< TargetType >( ) )
2266 {
2267 sides = Lang::DocumentDestination::TOPLEFT;
2268 if( remote )
2269 {
2270 throw Exceptions::CoreOutOfRange( id_, args, target_i, "The target can not be specified for remote destinations." );
2271 }
2272 }
2273 static Lang::Symbol SIDES_TopLeft( "topleft" );
2274 static Lang::Symbol SIDES_Page( "page" );
2275 static Lang::Symbol SIDES_Top( "top" );
2276 static Lang::Symbol SIDES_Left( "left" );
2277 static Lang::Symbol SIDES_Rectangle( "rectangle" );
2278 if( sidesVal != NullPtr< SidesModeType >( ) )
2279 {
2280 if( *sidesVal == SIDES_TopLeft )
2281 {
2282 sides = Lang::DocumentDestination::TOPLEFT;
2283 }
2284 else if( *sidesVal == SIDES_Page )
2285 {
2286 if( target != NullPtr< TargetType >( ) )
2287 {
2288 throw Exceptions::CoreOutOfRange( id_, args, sidesMode_i, "The sides mode cannot be page when a target object is present." );
2289 }
2290 sides = Lang::DocumentDestination::PAGE;
2291 }
2292 else if( *sidesVal == SIDES_Top )
2293 {
2294 sides = Lang::DocumentDestination::TOP;
2295 }
2296 else if( *sidesVal == SIDES_Left )
2297 {
2298 sides = Lang::DocumentDestination::LEFT;
2299 }
2300 else if( *sidesVal == SIDES_Rectangle )
2301 {
2302 sides = Lang::DocumentDestination::RECTANGLE;
2303 }
2304 else
2305 {
2306 std::ostringstream oss;
2307 oss << "Valid sides modes are the symbols { "
2308 << SIDES_TopLeft.name( ).getPtr( ) << ", "
2309 << SIDES_Page.name( ).getPtr( ) << ", "
2310 << SIDES_Top.name( ).getPtr( ) << ", "
2311 << SIDES_Left.name( ).getPtr( ) << ", "
2312 << SIDES_Rectangle.name( ).getPtr( )
2313 << " }." ;
2314 throw Exceptions::CoreOutOfRange( id_, args, sidesMode_i, strrefdup( oss ) );
2315 }
2316 }
2317
2318 ++argsi;
2319 typedef const Lang::Boolean FitToType;
2320 RefCountPtr< FitToType > fittobboxVal = Helpers::down_cast_CoreArgument< FitToType >( id_, args, argsi, callLoc, true );
2321 bool fittobbox = false;
2322 if( fittobboxVal != NullPtr< FitToType >( ) )
2323 {
2324 if( remote || sides == Lang::DocumentDestination::TOPLEFT || sides == Lang::DocumentDestination::RECTANGLE )
2325 {
2326 throw Exceptions::CoreOutOfRange( id_, args, argsi, "The fit-to-bbox flag cannot be specified in this mode." );
2327 }
2328 fittobbox = fittobboxVal->val_;
2329 }
2330
2331 ++argsi;
2332 typedef const Lang::Float ZoomType;
2333 RefCountPtr< ZoomType > zoomVal = Helpers::down_cast_CoreArgument< ZoomType >( id_, args, argsi, callLoc, true );
2334 double zoom = 0; // This will remain zero only if the zoom argument is not specified.
2335 if( zoomVal != NullPtr< ZoomType >( ) )
2336 {
2337 if( remote || sides != Lang::DocumentDestination::TOPLEFT )
2338 {
2339 throw Exceptions::CoreOutOfRange( id_, args, argsi, "The zoom can only be specified when using the top-left sides." );
2340 }
2341 zoom = zoomVal->val_;
2342 if( zoom <= 0 )
2343 {
2344 throw Exceptions::CoreOutOfRange( id_, args, argsi, "The zoom value must be positive." );
2345 }
2346 }
2347
2348 ++argsi;
2349 typedef const Lang::Boolean DoTransformType;
2350 bool doTransform = Helpers::down_cast_CoreArgument< DoTransformType >( id_, args, argsi, callLoc )->val_;
2351
2352 Kernel::ContRef cont = evalState->cont_;
2353 if( remote )
2354 {
2355 RefCountPtr< const Lang::DocumentDestination >
2356 taggedObj( new Lang::DocumentDestination( remote, name, outlineLevel,
2357 outlineText, outlineOpen, outlineBold, outlineItalic, outlineColor ) );
2358 cont->takeValue( RefCountPtr< const Lang::Value >
2359 ( new Lang::TaggedValue2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2360 evalState );
2361 }
2362 else
2363 {
2364 RefCountPtr< const Lang::DocumentDestination >
2365 taggedObj( new Lang::DocumentDestination( name, outlineLevel,
2366 outlineText, outlineOpen, outlineBold, outlineItalic, outlineColor,
2367 sides, target, fittobbox, zoom ) );
2368 if( doTransform )
2369 {
2370 cont->takeValue( RefCountPtr< const Lang::Value >
2371 ( new Lang::TaggedGeometric2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2372 evalState );
2373 }
2374 else
2375 {
2376 cont->takeValue( RefCountPtr< const Lang::Value >
2377 ( new Lang::TaggedValue2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2378 evalState );
2379 }
2380 }
2381 }
2382 };
2383
2384 class Core_importFont : public Lang::CoreFunction
2385 {
2386 public:
2387 struct CacheKey
2388 {
2389 bool outline_;
2390 RefCountPtr< const char > filename_;
2391 CacheKey( bool outline, const RefCountPtr< const char > & filename )
2392 : outline_( outline ), filename_( filename )
2393 { }
2394 ~CacheKey( )
2395 { }
2396 bool operator < ( const CacheKey & other ) const
2397 {
2398 if( ! outline_ && other.outline_ )
2399 {
2400 return true;
2401 }
2402 if( outline_ && ! other.outline_ )
2403 {
2404 return false;
2405 }
2406 return strcmp( filename_.getPtr( ), other.filename_.getPtr( ) ) < 0;
2407 }
2408 };
2409 private:
2410 static std::map< CacheKey, RefCountPtr< const Lang::Value > > cache;
2411 public:
2412 Core_importFont( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2413 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
2414 {
2415 formals_->appendEvaluatedCoreFormal( "family", Kernel::THE_SLOT_VARIABLE );
2416 formals_->appendEvaluatedCoreFormal( "style", Kernel::THE_VOID_VARIABLE );
2417 formals_->appendEvaluatedCoreFormal( "outline", Kernel::THE_FALSE_VARIABLE );
2418 }
2419 virtual void
2420 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2421 {
2422 #ifndef HAVE_FT2
2423 throw Exceptions::BuildRequirement( Interaction::BUILD_REQ_FREETYPE, id_, callLoc );
2424 #else
2425 args.applyDefaults( callLoc );
2426
2427 size_t argsi = 0;
2428 std::string full_filename;
2429 #ifndef HAVE_FONTCONFIG
2430 /* Here, it would be possible to allow the user to point out the font file directly instead of using FontConfig,
2431 * but currently there is no such option.
2432 */
2433 throw Exceptions::BuildRequirement( Interaction::BUILD_REQ_FONTCONFIG, id_, callLoc );
2434 #else
2435 FcPattern * pat = FcPatternCreate( );
2436 Helpers::AutoDestroyFcPattern destroy_pat( pat );
2437
2438 FcValue fc_fontformat;
2439 fc_fontformat.type = FcTypeString;
2440 fc_fontformat.u.s = reinterpret_cast< const FcChar8 * >( "TrueType" );
2441 FcPatternAdd( pat, "fontformat", fc_fontformat, FcFalse );
2442
2443 size_t argsi_family = argsi;
2444 typedef const Lang::String ArgType;
2445 RefCountPtr< ArgType > family = Helpers::down_cast_CoreArgument< ArgType >( id_, args, argsi_family, callLoc );
2446 FcValue fc_family;
2447 fc_family.type = FcTypeString;
2448 fc_family.u.s = reinterpret_cast< const FcChar8 * >( family->val_.getPtr( ) );
2449 FcPatternAdd( pat, "family", fc_family, FcFalse );
2450
2451 ++argsi;
2452 size_t argsi_style = argsi;
2453 RefCountPtr< ArgType > style = Helpers::down_cast_CoreArgument< ArgType >( id_, args, argsi_style, callLoc, true );
2454 FcValue fc_style;
2455 if( style != NullPtr< ArgType >( ) )
2456 {
2457 fc_style.type = FcTypeString;
2458 fc_style.u.s = reinterpret_cast< const FcChar8 * >( style->val_.getPtr( ) );
2459 FcPatternAdd( pat, "style", fc_family, FcFalse );
2460 }
2461
2462 FcFontSet * sysFonts = FcConfigGetFonts( NULL, FcSetSystem );
2463
2464 FcResult fc_res;
2465
2466 FcDefaultSubstitute( pat );
2467 FcConfigSubstitute( NULL, pat, FcMatchPattern ); /* Not sure if FcMatchPattern is the correct value to pass here. There are two more possible values, and no documentation. See fontconfig/fontconfig.h. */
2468 FcPattern * match_res = FcFontSetMatch( NULL, & sysFonts, 1, pat, & fc_res );
2469 if( match_res == 0 )
2470 {
2471 throw Exceptions::ExternalError( "FontConfig' FcFontSetMatch returned with failure." );
2472 }
2473 Helpers::AutoDestroyFcPattern destroy_match_res( match_res );
2474
2475 switch( fc_res )
2476 {
2477 case FcResultMatch:
2478 // OK, just continue;
2479 break;
2480 case FcResultNoMatch:
2481 throw Exceptions::OutOfRange( callLoc, "FontConfig returned no matching font." );
2482 case FcResultOutOfMemory:
2483 throw Exceptions::ExternalError( "FontConfig got out of memory." );
2484 case FcResultTypeMismatch:
2485 // {
2486 // std::ostringstream msg;
2487 // msg << "Unexpected FcResult from FcFontSetMatch: " << "FcResultTypeMismatch" << " (ignored)." ;
2488 // WARN_OR_THROW( Exceptions::InternalError( strrefdup( msg ), true ) );
2489 // }
2490 break;
2491 case FcResultNoId:
2492 // {
2493 // std::ostringstream msg;
2494 // msg << "Unexpected FcResult from FcFontSetMatch: " << "FcResultNoId" << " (ignored)." ;
2495 // WARN_OR_THROW( Exceptions::InternalError( strrefdup( msg ), true ) );
2496 // }
2497 break;
2498 default:
2499 // {
2500 // std::ostringstream msg;
2501 // msg << "Unexpected FcResult from FcFontSetMatch: " << fc_res << " (ignored)." ;
2502 // WARN_OR_THROW( Exceptions::InternalError( strrefdup( msg ), true ) );
2503 // }
2504 // throw Exceptions::InternalError( "Unexpected FcResult from FcFontSetMatch." );
2505 break;
2506 }
2507 // FcPatternPrint( match_res );
2508
2509 FcChar8 * fc_tmp_string;
2510 switch( FcPatternGetString( match_res, "fontformat", 0, & fc_tmp_string ) )
2511 {
2512 case FcResultMatch:
2513 // OK, just continue;
2514 break;
2515 case FcResultNoMatch:
2516 throw Exceptions::ExternalError( "FontConfig says that the font does not have a 'fontformat'." );
2517 case FcResultTypeMismatch:
2518 throw Exceptions::ExternalError( "FontConfig says 'fontformat' has the wrong type." );
2519 case FcResultNoId:
2520 throw Exceptions::ExternalError( "FontConfig says 'fontformat' is missing something." );
2521 case FcResultOutOfMemory:
2522 throw Exceptions::ExternalError( "FontConfig got out of memory." );
2523 }
2524 if( strcmp( reinterpret_cast< const char * >( fc_tmp_string ), "TrueType" ) != 0 ) // This is OK, since "TrueType" is in the ASCII range.
2525 {
2526 throw Exceptions::OutOfRange( callLoc, "Font file format not supported by Shapes, only TrueType is supported at the moment." );
2527 }
2528
2529 switch( FcPatternGetString( match_res, "file", 0, & fc_tmp_string ) )
2530 {
2531 case FcResultMatch:
2532 // OK, just continue;
2533 break;
2534 case FcResultNoMatch:
2535 throw Exceptions::ExternalError( "FontConfig says that the font does not have a 'file' (filename)." );
2536 case FcResultTypeMismatch:
2537 throw Exceptions::ExternalError( "FontConfig says 'file' has the wrong type." );
2538 case FcResultNoId:
2539 throw Exceptions::ExternalError( "FontConfig says 'file' is missing something." );
2540 case FcResultOutOfMemory:
2541 throw Exceptions::ExternalError( "FontConfig got out of memory." );
2542 }
2543 full_filename = reinterpret_cast< const char * >( fc_tmp_string ); /* Let us hope that this string is in the ASCII range! */
2544 #endif
2545
2546 ++argsi;
2547 size_t argsi_outline = argsi;
2548 bool outline = Helpers::down_cast_CoreArgument< const Lang::Boolean >( id_, args, argsi_outline, callLoc )->val_;
2549 CacheKey cacheKey( outline, strrefdup( full_filename.c_str( ) ) );
2550 {
2551 typedef typeof cache MapType;
2552 MapType::const_iterator i = cache.find( cacheKey );
2553 if( i != cache.end( ) )
2554 {
2555 Kernel::ContRef cont = evalState->cont_;
2556 cont->takeValue( i->second,
2557 evalState );
2558 return;
2559 }
2560 }
2561
2562
2563 FT_Face face;
2564 {
2565 FT_Error error = FT_New_Face( Kernel::theFreeType,
2566 full_filename.c_str( ),
2567 0,
2568 & face );
2569 if( error == FT_Err_Unknown_File_Format )
2570 {
2571 throw Exceptions::ExternalError( "Font file format not supported by FreeType." );
2572 }
2573 else if( error != 0 )
2574 {
2575 std::ostringstream msg;
2576 msg << "FreeType failed to open " << full_filename << ", reason: " << Kernel::FreeTypeErrorMessage( error ) ;
2577 throw Exceptions::ExternalError( strrefdup( msg ) );
2578 }
2579 }
2580 const char * PostScriptName = FT_Get_Postscript_Name( face ); /* See comment on the next line! */
2581 std::ostringstream baseFontName; /* The PostScriptName pointer shall only be used as long as this object is in scope. */
2582 if( PostScriptName == 0 )
2583 {
2584 for( const char * src = full_filename.c_str( ); *src != '\0'; ++src )
2585 {
2586 if( *src == '.' )
2587 {
2588 break;
2589 }
2590 if( *src != ' ' )
2591 {
2592 baseFontName << *src ;
2593 }
2594 }
2595 PostScriptName = baseFontName.str( ).c_str( );
2596 }
2597
2598 if( ! FT_IS_SFNT( face ) )
2599 {
2600 throw Exceptions::OutOfRange( callLoc, "Font file format not supported by Shapes, only TrueType is supported at the moment." );
2601 }
2602 if( ! outline )
2603 {
2604 #ifdef HAVE_FT2_10
2605 FT_UShort fsType = FT_Get_FSType_Flags( face );
2606 if( ( fsType & ( FT_FSTYPE_INSTALLABLE_EMBEDDING |
2607 FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING |
2608 FT_FSTYPE_EDITABLE_EMBEDDING ) )
2609 == 0 )
2610 {
2611 std::ostringstream msg;
2612 msg << "The font " << PostScriptName << " does not permit embedding, and cannot be used with Shapes. Flags: " << std::hex << static_cast< int >( fsType ) << "." ;
2613 throw Exceptions::MiscellaneousRequirement( strrefdup( msg ) );
2614 }
2615 #else
2616 throw Exceptions::MiscellaneousRequirement( strrefdup( "Shapes does not permit embedding of fonts, since your FreeType library is too old to provide licensing information about your fonts." ) );
2617 #endif
2618 }
2619
2620 FontMetrics::FreeType2_Metric * newMetrics = new FontMetrics::FreeType2_Metric( face );
2621 RefCountPtr< const FontMetrics::FontMetric > metrics = RefCountPtr< const FontMetrics::FontMetric >( newMetrics );
2622
2623 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
2624 RefCountPtr< SimplePDF::PDF_Object > resource = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
2625 (*dic)[ "Type" ] = SimplePDF::newName( "Font" );
2626 (*dic)[ "Subtype" ] = SimplePDF::newName( "Type0" );
2627
2628 RefCountPtr< SimplePDF::PDF_Dictionary > descendant;
2629 RefCountPtr< SimplePDF::PDF_Vector > descendants;
2630 descendants->vec.push_back( descendant );
2631 (*dic)[ "DescendantFonts" ] = descendants;
2632
2633 RefCountPtr< SimplePDF::PDF_ToUnicode::CharSet > usedChars;
2634
2635 (*descendant)[ "Type" ] = SimplePDF::newName( "Font" );
2636 (*descendant)[ "Subtype" ] = SimplePDF::newName( "CIDFontType2" );
2637
2638 RefCountPtr< SimplePDF::PDF_Name > fontName = RefCountPtr< SimplePDF::PDF_Name >( new SimplePDF::PDF_Name( PostScriptName ) );
2639 (*dic)[ "BaseFont" ] = fontName;
2640 (*descendant)[ "BaseFont" ] = fontName;
2641 (*dic)[ "Encoding" ] = SimplePDF::newName( "Identity-H" );
2642 (*descendant)[ "BaseFont" ] = fontName;
2643
2644 RefCountPtr< SimplePDF::PDF_Dictionary > CIDSystemInfo;
2645 (*CIDSystemInfo)[ "Registry" ] = SimplePDF::newString( "Adobe" );
2646 (*CIDSystemInfo)[ "Ordering" ] = SimplePDF::newString( "Identity" );
2647 (*CIDSystemInfo)[ "Supplement" ] = SimplePDF::newString( "0" );
2648 (*descendant)[ "CIDSystemInfo" ] = CIDSystemInfo;
2649 (*descendant)[ "CIDToGIDMap" ] = SimplePDF::newName( "Identity" );
2650
2651 (*descendant)[ "DW" ] = SimplePDF::newFloat( 0.7 * 1000 ); /* Default width. */
2652
2653 RefCountPtr< SimplePDF::PDF_Dictionary > fontDescriptor;
2654 (*fontDescriptor)[ "Type" ] = SimplePDF::newName( "FontDescriptor" );
2655 (*fontDescriptor)[ "FontName" ] = fontName;
2656 (*fontDescriptor)[ "Flags" ] = SimplePDF::newInt( (size_t)(1) << ( 6 - 1 ) ); // This is the "Nonsymbolic" flag, although we don't know if it really is a non-symbolic font...
2657 (*fontDescriptor)[ "FontBBox" ] =
2658 RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( newMetrics->fontBBoxXMin_ * 1000, newMetrics->fontBBoxYMin_ * 1000,
2659 newMetrics->fontBBoxXMax_ * 1000, newMetrics->fontBBoxYMax_ * 1000 ) );
2660 (*fontDescriptor)[ "ItalicAngle" ] = SimplePDF::newFloat( 0 );
2661 (*fontDescriptor)[ "Ascent" ] = SimplePDF::newFloat( 1 * 1000 );
2662 (*fontDescriptor)[ "Descent" ] = SimplePDF::newFloat( -0.5 * 1000 );
2663
2664 RefCountPtr< SimplePDF::PDF_Stream_out > fontFile = RefCountPtr< SimplePDF::PDF_Stream_out >( new SimplePDF::PDF_Stream_out( ) );
2665 (*fontFile)[ "Filter" ] = SimplePDF::newName( "FlateDecode" );
2666 std::ifstream iFile( full_filename.c_str( ) );
2667 if( ! iFile.is_open( ) )
2668 {
2669 throw Exceptions::FileReadOpenError( callLoc, strrefdup( full_filename ), 0, 0 );
2670 }
2671 {
2672 iFile.seekg( 0, std::ios::end );
2673 std::streamoff tmp = iFile.tellg( );
2674 std::streamsize size = tmp - static_cast< std::streamoff >( 0 );
2675 (*fontFile)[ "Length1" ] = SimplePDF::newInt( size );
2676 char * buf = new char[ size ];
2677 iFile.seekg( 0, std::ios::beg );
2678 iFile.read( buf, size );
2679 fontFile->data.write( buf, size );
2680 delete buf;
2681 }
2682 (*fontDescriptor)[ "FontFile2" ] = SimplePDF::indirect( fontFile, & Kernel::theIndirectObjectCount );
2683
2684 (*descendant)[ "FontDescriptor" ] = fontDescriptor;
2685
2686 RefCountPtr< const Lang::Font > res = RefCountPtr< const Lang::Font >( new Lang::FreeTypeFont( face,
2687 newMetrics->fontName_,
2688 outline,
2689 resource,
2690 metrics,
2691 usedChars ) );
2692 RefCountPtr< SimplePDF::PDF_ToUnicode > toUnicode( new SimplePDF::PDF_ToUnicode( usedChars, res ) );
2693 (*dic)[ "ToUnicode" ] = SimplePDF::indirect( toUnicode, & Kernel::theIndirectObjectCount );
2694 RefCountPtr< SimplePDF::PDF_Widths > widths( new SimplePDF::PDF_Widths( usedChars, res ) );
2695 (*descendant)[ "W" ] = SimplePDF::indirect( widths, & Kernel::theIndirectObjectCount );
2696
2697 {
2698 typedef typeof cache MapType;
2699 cache.insert( MapType::value_type( cacheKey, res ) );
2700 }
2701 Kernel::ContRef cont = evalState->cont_;
2702 cont->takeValue( res,
2703 evalState );
2704 #endif
2705 }
2706 };
2707
2708 std::map< Core_importFont::CacheKey, RefCountPtr< const Lang::Value > > Core_importFont::cache;
2709
2710 class Core_Unicode : public Lang::CoreFunction
2711 {
2712 public:
2713 Core_Unicode( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2714 : CoreFunction( ns, name )
2715 { }
2716 virtual void
2717 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2718 {
2719 const size_t ARITY = 1;
2720 CHECK_ARITY( args, ARITY, id_ );
2721
2722 size_t argsi = 0;
2723 typedef const Lang::Integer ArgType;
2724 ArgType::ValueType arg = Helpers::down_cast_CoreArgument< ArgType >( id_, args, argsi, callLoc )->val_;
2725 if( arg < 0 )
2726 {
2727 throw Exceptions::CoreOutOfRange( id_, args, argsi, "Unicode code points cannot be negative." );
2728 }
2729
2730 Kernel::ContRef cont = evalState->cont_;
2731 cont->takeValue( Kernel::ValueRef( new Lang::Character( arg ) ),
2732 evalState );
2733 }
2734 };
2735
2736 class Core_AdobeGlyphList : public Lang::CoreFunction
2737 {
2738 public:
2739 Core_AdobeGlyphList( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2740 : CoreFunction( ns, name )
2741 { }
2742 virtual void
2743 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2744 {
2745 const size_t ARITY = 1;
2746 CHECK_ARITY( args, ARITY, id_ );
2747
2748 size_t argsi = 0;
2749 typedef const Lang::Symbol ArgType;
2750 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( id_, args, argsi, callLoc );
2751 if( arg->isUnique( ) )
2752 {
2753 throw Exceptions::CoreOutOfRange( id_, args, argsi, "Unique symbols do not correspond to any glyphs." );
2754 }
2755 FontMetrics::GlyphList::UnicodeType res;
2756 const FontMetrics::GlyphList & glyphList = Helpers::requireGlyphList( );
2757 if( ! glyphList.name_to_UCS4( arg->name( ).getPtr( ), & res ) )
2758 {
2759 std::ostringstream msg;
2760 msg << "Unrecognized glyph name: " ;
2761 arg->show( msg );
2762 throw Exceptions::CoreOutOfRange( id_, args, argsi, strrefdup( msg ) );
2763 }
2764 Kernel::ContRef cont = evalState->cont_;
2765 cont->takeValue( Kernel::ValueRef( new Lang::Character( res ) ),
2766 evalState );
2767 }
2768 };
2769
2770 }
2771 }
2772
2773
2774 Lang::Core_range::Core_range( const RefCountPtr< const Ast::NamespacePath > & ns, const char * name )
2775 : CoreFunction( ns, name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
2776 {
2777 formals_->appendEvaluatedCoreFormal( "begin", Kernel::THE_VOID_VARIABLE );
2778 formals_->appendEvaluatedCoreFormal( "end", Kernel::THE_VOID_VARIABLE );
2779 formals_->appendEvaluatedCoreFormal( "step", Kernel::THE_VOID_VARIABLE );
2780 formals_->appendEvaluatedCoreFormal( "count", Kernel::THE_VOID_VARIABLE );
2781 }
2782
2783 void
2784 Lang::Core_range::call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2785 {
2786 RefCountPtr< const Interaction::CoreLocation > coreLoc( new Interaction::BoundLocation( id_ ) );
2787 makeRange( coreLoc, evalState, args, callLoc );
2788 }
2789
2790 void
2791 Lang::Core_range::makeRange( const RefCountPtr< const Interaction::CoreLocation > & coreLoc, Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc, bool isSpan, RefCountPtr< const Lang::Value > lastPtr )
2792 {
2793 const size_t argsi_begin = 0;
2794 const size_t argsi_end = 1;
2795 const size_t argsi_step = 2;
2796 const size_t argsi_count = 3;
2797
2798 typedef const Lang::Integer CountType;
2799
2800 args.applyDefaults( callLoc );
2801
2802 try
2803 {
2804 typedef const Lang::Integer ArgType;
2805
2806 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi_begin ), true );
2807 RefCountPtr< ArgType > endPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_end, callLoc, true );
2808 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
2809 {
2810 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", coreLoc, callLoc );
2811 }
2812 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_step, callLoc, true );
2813 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( coreLoc, args, argsi_count, callLoc, true );
2814
2815 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
2816 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
2817 {
2818 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", coreLoc, callLoc );
2819 }
2820
2821 ArgType::ValueType begin = 0;
2822 ArgType::ValueType step = 1;
2823 ArgType::ValueType last = isSpan ? lastPtr.down_cast< ArgType >( )->val_ : 0;
2824 size_t count = 0;
2825
2826 if( stepPtr != NullPtr< ArgType >( ) )
2827 {
2828 step = stepPtr->val_;
2829 }
2830 if( countPtr != NullPtr< CountType >( ) )
2831 {
2832 if( countPtr->val_ < 0 )
2833 {
2834 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_count, "The <count> must not be negative." );
2835 }
2836 count = countPtr->val_;
2837 }
2838
2839 if( beginPtr == NullPtr< ArgType >( ) )
2840 {
2841 if( countPtr == NullPtr< CountType >( ) )
2842 {
2843 if( isSpan )
2844 {
2845 if( endPtr->val_ < 0 )
2846 {
2847 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a span of integers and <begin> is omitted while <end> is negative.", coreLoc, callLoc );
2848 }
2849 count = 1 + endPtr->val_ / step;
2850 }
2851 else
2852 {
2853 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of integers and <begin> is omitted.", coreLoc, callLoc );
2854 }
2855 }
2856 begin = endPtr->val_ - ( count - 1 ) * step;
2857 }
2858 else if( endPtr == NullPtr< ArgType >( ) )
2859 {
2860 begin = beginPtr->val_;
2861 if( countPtr == NullPtr< CountType >( ) )
2862 {
2863 if( isSpan )
2864 {
2865 if( last < begin )
2866 {
2867 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of integers and <end> is omitted while <begin> exceeds %last.", coreLoc, callLoc );
2868 }
2869 count = ( last - begin ) / step + 1;
2870 }
2871 else
2872 {
2873 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of integers and <end> is omitted.", coreLoc, callLoc );
2874 }
2875 }
2876 }
2877 else
2878 {
2879 if( countPtr != NullPtr< CountType >( ) )
2880 {
2881 throw Exceptions::CoreRequirement( "It is an error to provide the <count> argument when constructing a range of integers from <begin> to <end>.", coreLoc, args.getLoc( argsi_count ) );
2882 }
2883
2884 begin = beginPtr->val_;
2885 if( ( endPtr->val_ >= begin && step <= 0 )
2886 ||
2887 ( endPtr->val_ <= begin && step >= 0 ) )
2888 {
2889 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_step, "When <count> is omitted, the sign of <step> must agree with the order of <begin> and <end>." );
2890 }
2891 count = 1 + ( endPtr->val_ - begin ) / step;
2892 }
2893
2894 Kernel::ContRef cont = evalState->cont_;
2895 if( count == 0 )
2896 {
2897 cont->takeValue( Lang::THE_CONS_NULL,
2898 evalState );
2899 }
2900 else
2901 {
2902 cont->takeValue( RefCountPtr< const Lang::SingleList >( new Lang::SingleListRange< ArgType >( begin, step, count ) ),
2903 evalState );
2904 }
2905 return;
2906 }
2907 catch( const NonLocalExit::NotThisType & ball )
2908 {
2909 /* Never mind, see below. */
2910 }
2911
2912 try
2913 {
2914 typedef const Lang::Float ArgType;
2915
2916 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi_begin ), true );
2917 RefCountPtr< ArgType > endPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_end, callLoc, true );
2918 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
2919 {
2920 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", coreLoc, callLoc );
2921 }
2922 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_step, callLoc, true );
2923 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( coreLoc, args, argsi_count, callLoc, true );
2924
2925 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
2926 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
2927 {
2928 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", coreLoc, callLoc );
2929 }
2930
2931 ArgType::ValueType begin = 0;
2932 ArgType::ValueType step = 1;
2933 ArgType::ValueType last = isSpan ? lastPtr.down_cast< ArgType >( )->val_ : 0;
2934 size_t count = 0;
2935
2936 if( stepPtr != NullPtr< ArgType >( ) )
2937 {
2938 step = stepPtr->val_;
2939 }
2940 if( countPtr != NullPtr< CountType >( ) )
2941 {
2942 if( countPtr->val_ < 0 )
2943 {
2944 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_count, "The <count> must not be negative." );
2945 }
2946 count = countPtr->val_;
2947 }
2948
2949 if( beginPtr == NullPtr< ArgType >( ) )
2950 {
2951 if( countPtr == NullPtr< CountType >( ) )
2952 {
2953 if( isSpan )
2954 {
2955 if( endPtr->val_ < 0 )
2956 {
2957 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a span of floats and <begin> is omitted while <end> is negative.", coreLoc, callLoc );
2958 }
2959 count = 1 + static_cast< size_t >( endPtr->val_ / step );
2960 }
2961 else
2962 {
2963 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of floats and <begin> is omitted.", coreLoc, callLoc );
2964 }
2965 }
2966 begin = endPtr->val_ - ( count - 1 ) * step;
2967 }
2968 else if( endPtr == NullPtr< ArgType >( ) )
2969 {
2970 begin = beginPtr->val_;
2971 if( countPtr == NullPtr< CountType >( ) )
2972 {
2973 if( isSpan )
2974 {
2975 if( last < begin )
2976 {
2977 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of floats and <end> is omitted while <begin> exceeds %last.", coreLoc, callLoc );
2978 }
2979 count = 1 + static_cast< size_t >( ( last - begin ) / step );
2980 }
2981 else
2982 {
2983 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of floats and <end> is omitted.", coreLoc, callLoc );
2984 }
2985 }
2986 }
2987 else
2988 {
2989 begin = beginPtr->val_;
2990 // When we reach here, we know that at most one of <step> and <count> is provided.
2991 if( countPtr != NullPtr< CountType >( ) )
2992 {
2993 if( count < 2 )
2994 {
2995 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_count, "When <step> is omitted, the <count> be at least 2." );
2996 }
2997 step = ( endPtr->val_ - begin ) / ( count - 1 );
2998 }
2999 else
3000 {
3001 /* If <step> is not provided, it defaults to 1, see above. */
3002 if( step == 0 )
3003 {
3004 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_step, "When <count> is omitted, <step> must not be zero." );
3005 }
3006 ArgType::ValueType tmpCount = 1 + ( endPtr->val_ - begin ) / step;
3007 if( tmpCount < 1 )
3008 {
3009 count = 0;
3010 }
3011 else
3012 {
3013 if( tmpCount > std::numeric_limits< size_t >::max( ) )
3014 {
3015 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_step, "When <count> is omitted, too small <step> values cause overflow in the number of elements." );
3016 }
3017 count = static_cast< size_t >( tmpCount );
3018 }
3019 }
3020 }
3021
3022 Kernel::ContRef cont = evalState->cont_;
3023 if( count == 0 )
3024 {
3025 cont->takeValue( Lang::THE_CONS_NULL,
3026 evalState );
3027 }
3028 else
3029 {
3030 cont->takeValue( RefCountPtr< const Lang::SingleList >( new Lang::SingleListRange< ArgType >( begin, step, count ) ),
3031 evalState );
3032 }
3033 return;
3034 }
3035 catch( const NonLocalExit::NotThisType & ball )
3036 {
3037 /* Never mind, see below. */
3038 }
3039
3040 try
3041 {
3042 typedef const Lang::Length ArgType;
3043
3044 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi_begin ), true );
3045 RefCountPtr< ArgType > endPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_end, callLoc, true );
3046 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
3047 {
3048 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", coreLoc, callLoc );
3049 }
3050 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( coreLoc, args, argsi_step, callLoc, true );
3051 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( coreLoc, args, argsi_count, callLoc, true );
3052
3053 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
3054 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
3055 {
3056 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", coreLoc, callLoc );
3057 }
3058
3059 ArgType::ValueType begin = ArgType::ValueType( 0 );
3060 ArgType::ValueType step = ArgType::ValueType( 1 ); /* This is a "default" value that one is not allowed to use! */
3061 ArgType::ValueType last = isSpan ? lastPtr.down_cast< ArgType >( )->get( ) : Concrete::ZERO_LENGTH;
3062 size_t count = 0;
3063
3064 if( stepPtr != NullPtr< ArgType >( ) )
3065 {
3066 step = stepPtr->get( );
3067 }
3068 if( countPtr != NullPtr< CountType >( ) )
3069 {
3070 if( countPtr->val_ < 0 )
3071 {
3072 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_count, "The <count> must not be negative." );
3073 }
3074 count = countPtr->val_;
3075 }
3076
3077 if( beginPtr == NullPtr< ArgType >( ) )
3078 {
3079 if( stepPtr == NullPtr< ArgType >( ) )
3080 {
3081 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of lengths when <begin> is omitted.", coreLoc, callLoc );
3082 }
3083 if( countPtr == NullPtr< CountType >( ) )
3084 {
3085 if( isSpan )
3086 {
3087 if( endPtr->get( ) < Concrete::ZERO_LENGTH )
3088 {
3089 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a span of lengths and <begin> is omitted while <end> is negative.", coreLoc, callLoc );
3090 }
3091 count = 1 + static_cast< size_t >( endPtr->get( ) / step );
3092 }
3093 else
3094 {
3095 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of lengths and <begin> is omitted.", coreLoc, callLoc );
3096 }
3097 }
3098 begin = endPtr->get( ) - ( count - 1 ) * step;
3099 }
3100 else if( endPtr == NullPtr< ArgType >( ) )
3101 {
3102 begin = beginPtr->get( );
3103 if( stepPtr == NullPtr< ArgType >( ) )
3104 {
3105 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of lengths when <end> is omitted.", coreLoc, callLoc );
3106 }
3107 if( countPtr == NullPtr< CountType >( ) )
3108 {
3109 if( isSpan )
3110 {
3111 if( last < begin )
3112 {
3113 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of lengths and <end> is omitted while <begin> exceeds %last.", coreLoc, callLoc );
3114 }
3115 count = static_cast< size_t >( ( last - begin ) / step ) + 1;
3116 }
3117 else
3118 {
3119 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of lengths and <end> is omitted.", coreLoc, callLoc );
3120 }
3121 }
3122 }
3123 else
3124 {
3125 begin = beginPtr->get( );
3126 if( stepPtr == NullPtr< ArgType >( ) && countPtr == NullPtr< CountType >( ) )
3127 {
3128 throw Exceptions::CoreRequirement( "Either of the <step> and <count> arguments must be provided when constructing a range of lengths from <begin> to <end>.", coreLoc, callLoc );
3129 }
3130 // When we reach here, we know that exactly one of <step> and <count> is provided.
3131 if( stepPtr != NullPtr< ArgType >( ) )
3132 {
3133 if( step == 0 )
3134 {
3135 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_step, "When <count> is omitted, <step> must not be zero." );
3136 }
3137 double tmpCount = 1 + ( endPtr->get( ) - begin ) / step;
3138 if( tmpCount < 1 )
3139 {
3140 count = 0;
3141 }
3142 else
3143 {
3144 if( tmpCount > std::numeric_limits< size_t >::max( ) )
3145 {
3146 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_step, "When <count> is omitted, too small <step> values cause overflow in the number of elements." );
3147 }
3148 count = static_cast< size_t >( tmpCount );
3149 }
3150 }
3151 else
3152 {
3153 if( count < 2 )
3154 {
3155 throw Exceptions::CoreOutOfRange( coreLoc, args, argsi_count, "When <step> is omitted, the <count> be at least 2." );
3156 }
3157 step = ( endPtr->get( ) - begin ) / ( count - 1 );
3158 }
3159 }
3160
3161 Kernel::ContRef cont = evalState->cont_;
3162 if( count == 0 )
3163 {
3164 cont->takeValue( Lang::THE_CONS_NULL,
3165 evalState );
3166 }
3167 else
3168 {
3169 cont->takeValue( RefCountPtr< const Lang::SingleList >( new Lang::SingleListRange< ArgType >( begin, step, count ) ),
3170 evalState );
3171 }
3172 return;
3173 }
3174 catch( const NonLocalExit::NotThisType & ball )
3175 {
3176 /* Never mind, see below. */
3177 }
3178
3179 throw Exceptions::CoreTypeMismatch( callLoc, coreLoc, args, 0, Helpers::typeSetString( Lang::Integer::staticTypeName( ), Lang::Float::staticTypeName( ), Lang::Length::staticTypeName( ) ) );
3180 }
3181
3182
3183 Kernel::Core_graph_cont_partitions::Core_graph_cont_partitions( RefCountPtr< const Lang::Value > nodes, const Ast::SourceLocation & nodesLoc, RefCountPtr< const Lang::Value > edges, const Ast::SourceLocation & edgesLoc, RefCountPtr< const Kernel::GraphDomain > domain, const Kernel::ContRef & cont, const Ast::SourceLocation & partitionsLoc )
3184 : Kernel::Continuation( partitionsLoc ), nodes_( nodes ), nodesLoc_( nodesLoc ), edges_( edges ), edgesLoc_( edgesLoc ), domain_( domain ), cont_( cont )
3185 { }
3186
3187 Kernel::Core_graph_cont_partitions::~Core_graph_cont_partitions( )
3188 { }
3189
3190 void
3191 Kernel::Core_graph_cont_partitions::takeValue( const RefCountPtr< const Lang::Value > & partitionsUntyped, Kernel::EvalState * evalState, bool dummy ) const
3192 {
3193 typedef const Lang::SingleList ArgType;
3194 RefCountPtr< ArgType > partitions = Helpers::down_cast< ArgType >( partitionsUntyped, "< Internal error situation in Core_graph_cont_partitions >" );
3195
3196 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation
3197 ( Kernel::ContRef( new Kernel::Core_graph_cont_nodes( edges_, edgesLoc_, domain_, partitions, cont_, traceLoc_, nodesLoc_ ) ),
3198 nodesLoc_,
3199 true ) );
3200 Kernel::ContRef cont = evalState->cont_;
3201 cont->takeValue( nodes_, evalState );
3202 }
3203
3204 Kernel::ContRef
3205 Kernel::Core_graph_cont_partitions::up( ) const
3206 {
3207 return cont_;
3208 }
3209
3210 RefCountPtr< const char >
3211 Kernel::Core_graph_cont_partitions::description( ) const
3212 {
3213 return strrefdup( "force list of partitions data" );
3214 }
3215
3216 void
3217 Kernel::Core_graph_cont_partitions::gcMark( Kernel::GCMarkedSet & marked )
3218 {
3219 const_cast< Lang::Value * >( nodes_.getPtr( ) )->gcMark( marked );
3220 const_cast< Lang::Value * >( edges_.getPtr( ) )->gcMark( marked );
3221 cont_->gcMark( marked );
3222 }
3223
3224
3225 Kernel::Core_graph_cont_nodes::Core_graph_cont_nodes( RefCountPtr< const Lang::Value > edges, const Ast::SourceLocation & edgesLoc, RefCountPtr< const Kernel::GraphDomain > domain, const RefCountPtr< const Lang::SingleList > & partitions, const Kernel::ContRef & cont, const Ast::SourceLocation & partitionsLoc, const Ast::SourceLocation & nodesLoc )
3226 : Kernel::Continuation( nodesLoc ), edges_( edges ), edgesLoc_( edgesLoc ), domain_( domain ), partitions_( partitions ), partitionsLoc_( partitionsLoc ), cont_( cont )
3227 { }
3228
3229 Kernel::Core_graph_cont_nodes::~Core_graph_cont_nodes( )
3230 { }
3231
3232 void
3233 Kernel::Core_graph_cont_nodes::takeValue( const RefCountPtr< const Lang::Value > & nodesUntyped, Kernel::EvalState * evalState, bool dummy ) const
3234 {
3235 typedef const Lang::SingleList ArgType;
3236 RefCountPtr< ArgType > nodes = Helpers::down_cast< ArgType >( nodesUntyped, "< Internal error situation in Core_graph_cont_nodes >" );
3237
3238 evalState->cont_ = Kernel::ContRef( new Kernel::ForcingListContinuation
3239 ( Kernel::ContRef( new Kernel::Core_graph_cont_edges( nodes, domain_, partitions_, cont_, traceLoc_, partitionsLoc_, edgesLoc_ ) ),
3240 edgesLoc_,
3241 true ) );
3242 Kernel::ContRef cont = evalState->cont_;
3243 cont->takeValue( edges_, evalState );
3244 }
3245
3246 Kernel::ContRef
3247 Kernel::Core_graph_cont_nodes::up( ) const
3248 {
3249 return cont_;
3250 }
3251
3252 RefCountPtr< const char >
3253 Kernel::Core_graph_cont_nodes::description( ) const
3254 {
3255 return strrefdup( "force list of node data" );
3256 }
3257
3258 void
3259 Kernel::Core_graph_cont_nodes::gcMark( Kernel::GCMarkedSet & marked )
3260 {
3261 const_cast< Lang::Value * >( edges_.getPtr( ) )->gcMark( marked );
3262 cont_->gcMark( marked );
3263 }
3264
3265
3266 Kernel::Core_graph_cont_edges::Core_graph_cont_edges( RefCountPtr< const Lang::SingleList > nodes, RefCountPtr< const Kernel::GraphDomain > domain, const RefCountPtr< const Lang::SingleList > & partitions, const Kernel::ContRef & cont, const Ast::SourceLocation & nodesLoc, const Ast::SourceLocation & partitionsLoc, const Ast::SourceLocation & edgesLoc )
3267 : Kernel::Continuation( edgesLoc ), nodes_( nodes ), domain_( domain ), partitions_( partitions ), nodesLoc_( nodesLoc ), partitionsLoc_( partitionsLoc ), cont_( cont )
3268 { }
3269
3270 Kernel::Core_graph_cont_edges::~Core_graph_cont_edges( )
3271 { }
3272
3273 void
3274 Kernel::Core_graph_cont_edges::takeValue( const RefCountPtr< const Lang::Value > & edgesUntyped, Kernel::EvalState * evalState, bool dummy ) const
3275 {
3276 typedef const Lang::SingleList ArgType;
3277 RefCountPtr< ArgType > edges = Helpers::down_cast< ArgType >( edgesUntyped, "< Internal error situation in Core_graph_cont_edges >" );
3278
3279 RefCountPtr< const Lang::Graph > graph = constructGraph( edges, evalState->env_, evalState->dyn_ );
3280
3281 evalState->cont_ = cont_;
3282 cont_->takeValue( graph,
3283 evalState );
3284 }
3285
3286 Kernel::ContRef
3287 Kernel::Core_graph_cont_edges::up( ) const
3288 {
3289 return cont_;
3290 }
3291
3292 RefCountPtr< const char >
3293 Kernel::Core_graph_cont_edges::description( ) const
3294 {
3295 return strrefdup( "force list of edge data" );
3296 }
3297
3298 void
3299 Kernel::Core_graph_cont_edges::gcMark( Kernel::GCMarkedSet & marked )
3300 {
3301 const_cast< Lang::SingleList * >( nodes_.getPtr( ) )->gcMark( marked );
3302 cont_->gcMark( marked );
3303 }
3304
3305 namespace Shapes
3306 {
3307 namespace Kernel
3308 {
3309
3310 NodeDataReceiverFormals theNodeDataReceiverFormals;
3311 EdgeDataReceiverFormals theEdgeDataReceiverFormals;
3312
3313 }
3314 }
3315
3316 RefCountPtr< const Lang::Graph >
3317 Kernel::Core_graph_cont_edges::constructGraph( const RefCountPtr< const Lang::SingleList > & edges, Kernel::PassedEnv env, Kernel::PassedDyn dyn ) const
3318 {
3319 std::list< Kernel::NodeData > nodeData;
3320 std::list< Kernel::EdgeData > edgeData;
3321
3322 {
3323 RefCountPtr< const Lang::SingleListPair > p = nodes_.down_cast< const Lang::SingleListPair >( );
3324 while( p != NullPtr< const Lang::SingleListPair >( ) ){
3325 RefCountPtr< const Lang::Value > key = RefCountPtr< const Lang::Value >( NullPtr< const Lang::Value >( ) );
3326 RefCountPtr< const Lang::Value > value = Lang::THE_VOID;
3327 RefCountPtr< const Lang::Value > partition = Lang::THE_VOID;
3328
3329 try
3330 {
3331 key = p->car_->tryVal< const Lang::Symbol >( );
3332 goto keyDone;
3333 }
3334 catch( const NonLocalExit::NotThisType & ball )
3335 {
3336 /* Never mind, see below. */
3337 }
3338
3339 try
3340 {
3341 key = p->car_->tryVal< const Lang::Integer >( );
3342 goto keyDone;
3343 }
3344 catch( const NonLocalExit::NotThisType & ball )
3345 {
3346 /* Never mind, see below. */
3347 }
3348
3349 try
3350 {
3351 RefCountPtr< const Lang::Structure > node = p->car_->tryVal< const Lang::Structure >( );
3352 /* Argument 0: key
3353 * Argument 1: value
3354 * Argument 2: partition
3355 */
3356 Kernel::Arguments args( & theNodeDataReceiverFormals );
3357 node->argList_->bind( & args, node->values_, env, dyn );
3358 args.applyDefaults( nodesLoc_ );
3359 key = args.getValue( 0 );
3360 value = args.getValue( 1 );
3361 partition = args.getValue( 2 );
3362 goto keyDone;
3363 }
3364 catch( const NonLocalExit::NotThisType & ball )
3365 {
3366 /* Never mind, see below. */
3367 }
3368
3369 throw Exceptions::TypeMismatch( traceLoc_, "Node element in graph construction", p->car_->getUntyped( )->getTypeName( ), Exceptions::GraphKeyTypeMismatch::expectedTypeOrStructure );
3370
3371 keyDone:
3372 nodeData.push_back( Kernel::NodeData( key, value, partition ) );
3373 p = p->cdr_.down_cast< const Lang::SingleListPair >( );
3374 }
3375 }
3376
3377 {
3378 RefCountPtr< const Lang::SingleListPair > p = edges.down_cast< const Lang::SingleListPair >( );
3379 while( p != NullPtr< const Lang::SingleListPair >( ) ){
3380 RefCountPtr< const Lang::Structure > edge = p->car_->getVal< const Lang::Structure >( "EdgeData for graph construction." );
3381 /* Argument 0: source
3382 * Argument 1: target
3383 * Argument 2: value
3384 * Argument 3: directed
3385 */
3386 Kernel::Arguments args( & theEdgeDataReceiverFormals );
3387 edge->argList_->bind( & args, edge->values_, env, dyn );
3388 args.applyDefaults( traceLoc_ );
3389 bool directed;
3390 {
3391 RefCountPtr< const Lang::Boolean > directedBoolean = args.getValue( 4 ).down_cast< const Lang::Boolean >( );
3392 if( directedBoolean != NullPtr< const Lang::Boolean >( ) ){
3393 directed = directedBoolean->val_;
3394 }else{
3395 RefCountPtr< const Lang::Void > directedVoid = args.getValue( 4 ).down_cast< const Lang::Void >( );
3396 if( directedVoid != NullPtr< const Lang::Void >( ) ){
3397 if( domain_->directed( ) && not domain_->undirected( ) )
3398 directed = true;
3399 else if( not domain_->directed( ) && domain_->undirected( ) )
3400 directed = false;
3401 else
3402 throw Exceptions::MiscellaneousRequirement( traceLoc_, "The EdgeData field 'directed' must be specified since the graph domain does not determine a default interpretation." );
3403 }else{
3404 throw Exceptions::TypeMismatch( traceLoc_, "EdgeData field 'directed'.", args.getValue( 3 )->getTypeName( ), Helpers::typeSetString( Lang::Boolean::staticTypeName( ), Lang::Void::staticTypeName( ) ) );
3405 }
3406 }
3407 }
3408
3409 RefCountPtr< const Lang::Value > sourceKey = args.getValue( 0 );
3410 RefCountPtr< const Lang::Value > targetKey = args.getValue( 1 );
3411 RefCountPtr< const Lang::Value > value = args.getValue( 2 );
3412 RefCountPtr< const Lang::Value > label = args.getValue( 3 );
3413 edgeData.push_back( Kernel::EdgeData( directed, sourceKey, targetKey, value, label ) );
3414 p = p->cdr_.down_cast< const Lang::SingleListPair >( );
3415 }
3416 }
3417
3418 return Helpers::graphFromNodeEdgeData( *domain_, partitions_, nodeData, edgeData, partitionsLoc_, traceLoc_ );
3419 }
3420
3421
3422 Kernel::Core_walk_cont_edges::Core_walk_cont_edges( const RefCountPtr< const Lang::Graph > & graph, const RefCountPtr< const Lang::Node > & first, const RefCountPtr< const Lang::Node > & last, const Ast::SourceLocation & edgesLoc, const Kernel::ContRef & cont, const Ast::SourceLocation & callLoc )
3423 : Kernel::Continuation( edgesLoc ), graph_( graph ), first_( first ), last_( last ), callLoc_( callLoc ), cont_( cont )
3424 { }
3425
3426 Kernel::Core_walk_cont_edges::~Core_walk_cont_edges( )
3427 { }
3428
3429 void
3430 Kernel::Core_walk_cont_edges::takeValue( const RefCountPtr< const Lang::Value > & edgesUntyped, Kernel::EvalState * evalState, bool dummy ) const
3431 {
3432 typedef const Lang::SingleList ArgType;
3433 RefCountPtr< ArgType > edges = Helpers::down_cast< ArgType >( edgesUntyped, "< Internal error situation in Core_walk_cont_edges >" );
3434
3435 RefCountPtr< const Lang::Walk > walk( new Lang::Walk( graph_, first_, last_, edges, traceLoc_, callLoc_ ) );
3436
3437 evalState->cont_ = cont_;
3438 cont_->takeValue( walk,
3439 evalState );
3440 }
3441
3442 Kernel::ContRef
3443 Kernel::Core_walk_cont_edges::up( ) const
3444 {
3445 return cont_;
3446 }
3447
3448 RefCountPtr< const char >
3449 Kernel::Core_walk_cont_edges::description( ) const
3450 {
3451 return strrefdup( "force list of walk edges" );
3452 }
3453
3454 void
3455 Kernel::Core_walk_cont_edges::gcMark( Kernel::GCMarkedSet & marked )
3456 {
3457 const_cast< Lang::Graph * >( graph_.getPtr( ) )->gcMark( marked );
3458 const_cast< Lang::Node * >( first_.getPtr( ) )->gcMark( marked );
3459 const_cast< Lang::Node * >( last_.getPtr( ) )->gcMark( marked );
3460 cont_->gcMark( marked );
3461 }
3462
3463
3464 /*
3465 * To avoid problems with initialization order (Kernel::THE_VOID_VARIABLE has to be initialized first), we first
3466 * initialize with an ugly null value, and then set the correct value when the real function is registered below.
3467 */
3468 RefCountPtr< const Lang::CoreFunction > Lang::THE_FUNCTION_RANGE = RefCountPtr< const Lang::CoreFunction >( NullPtr< const Lang::CoreFunction >( ) );
3469
3470 void
3471 Kernel::registerCore_construct( Kernel::Environment * env )
3472 {
3473 Lang::THE_FUNCTION_RANGE = RefCountPtr< const Lang::CoreFunction >( new Lang::Core_range( Lang::THE_NAMESPACE_Shapes_Data, "range" ) );
3474
3475 env->initDefineCoreFunction( new Lang::Core_cons( Lang::THE_NAMESPACE_Shapes_Data, "cons" ) );
3476 env->initDefineCoreFunction( new Lang::Core_list( Lang::THE_NAMESPACE_Shapes_Data, "list" ) );
3477 env->initDefineCoreFunction( new Lang::Core_unlist( Lang::THE_NAMESPACE_Shapes_Data, "unlist" ) );
3478 env->initDefineCoreFunction( new Lang::Core_isnil( Lang::THE_NAMESPACE_Shapes_Data, "nil?" ) );
3479 env->initDefineCoreFunction( Lang::THE_FUNCTION_RANGE );
3480 env->initDefineCoreFunction( new Lang::Core_span( Lang::THE_NAMESPACE_Shapes_Data, "span" ) );
3481 env->initDefineCoreFunction( new Lang::Core_shift( Lang::THE_NAMESPACE_Shapes_Geometry, "shift" ) );
3482 env->initDefineCoreFunction( new Lang::Core_shift3d( Lang::THE_NAMESPACE_Shapes_Geometry3D, "shift" ) );
3483 env->initDefineCoreFunction( new Lang::Core_rotate( Lang::THE_NAMESPACE_Shapes_Geometry, "rotate" ) );
3484 env->initDefineCoreFunction( new Lang::Core_rotate3d( Lang::THE_NAMESPACE_Shapes_Geometry3D, "rotate" ) );
3485 env->initDefineCoreFunction( new Lang::Core_scale( Lang::THE_NAMESPACE_Shapes_Geometry, "scale" ) );
3486 env->initDefineCoreFunction( new Lang::Core_scale3d( Lang::THE_NAMESPACE_Shapes_Geometry3D, "scale" ) );
3487 env->initDefineCoreFunction( new Lang::Core_affinetransform( Lang::THE_NAMESPACE_Shapes_Geometry, "affinetransform" ) );
3488 env->initDefineCoreFunction( new Lang::Core_affinetransform3d( Lang::THE_NAMESPACE_Shapes_Geometry3D, "affinetransform" ) );
3489 env->initDefineCoreFunction( new Lang::Core_inverse( Lang::THE_NAMESPACE_Shapes_Geometry, "inverse" ) );
3490 env->initDefineCoreFunction( new Lang::Core_inverse3d( Lang::THE_NAMESPACE_Shapes_Geometry3D, "inverse" ) );
3491
3492 env->initDefineCoreFunction( new Lang::Core_formxo( Lang::THE_NAMESPACE_Shapes_Graphics_PDF, "formxo" ) );
3493 env->initDefineCoreFunction( new Lang::Core_importRasterImage( Lang::THE_NAMESPACE_Shapes_Graphics, "import_raster" ) );
3494 env->initDefineCoreFunction( new Lang::Core_transparencygroup( Lang::THE_NAMESPACE_Shapes_Graphics, "tgroup" ) );
3495
3496 env->initDefineCoreFunction( new Lang::Core_tag( Lang::THE_NAMESPACE_Shapes_Graphics_Tag, "tag" ) );
3497 env->initDefineCoreFunction( new Lang::Core_find( Lang::THE_NAMESPACE_Shapes_Graphics_Tag, "find" ) );
3498 env->initDefineCoreFunction( new Lang::Core_findall( Lang::THE_NAMESPACE_Shapes_Graphics_Tag, "findall" ) );
3499
3500 env->initDefineCoreFunction( new Lang::Core_ambient_light( Lang::THE_NAMESPACE_Shapes_Traits_Light, "ambient_light" ) );
3501 env->initDefineCoreFunction( new Lang::Core_specular_light( Lang::THE_NAMESPACE_Shapes_Traits_Light, "specular_light" ) );
3502 env->initDefineCoreFunction( new Lang::Core_distant_light( Lang::THE_NAMESPACE_Shapes_Traits_Light, "distant_light" ) );
3503 env->initDefineCoreFunction( new Lang::Core_phong( Lang::THE_NAMESPACE_Shapes_Traits_Light, "phong" ) );
3504
3505 env->initDefineCoreFunction( new Lang::Core_vector( Lang::THE_NAMESPACE_Shapes_Data, "vector" ) );
3506 env->initDefineCoreFunction( new Lang::Core_graph( Lang::THE_NAMESPACE_Shapes_Data, "graph" ) );
3507 env->initDefineCoreFunction( new Lang::Core_walk( Lang::THE_NAMESPACE_Shapes_Data, "walk" ) );
3508 env->initDefineCoreFunction( new Lang::Core_importPDFpages( Lang::THE_NAMESPACE_Shapes_Graphics, "import" ) );
3509
3510 env->initDefineCoreFunction( new Lang::Core_svg_path( Lang::THE_NAMESPACE_Shapes_Geometry, "svg_path" ) );
3511
3512 env->initDefineCoreFunction( new Lang::Core_sprintf( Lang::THE_NAMESPACE_Shapes_String, "sprintf" ) );
3513 env->initDefineCoreFunction( new Lang::Core_strftime( Lang::THE_NAMESPACE_Shapes_String, "strftime" ) );
3514
3515 env->initDefineCoreFunction( new Lang::Core_newrandom( Lang::THE_NAMESPACE_Shapes_Numeric_Random, "newRandom" ) );
3516 env->initDefineCoreFunction( new Lang::Core_devrandom( Lang::THE_NAMESPACE_Shapes_Numeric_Random, "devRandom" ) );
3517
3518 env->initDefineCoreFunction( new Lang::Core_destination( Lang::THE_NAMESPACE_Shapes_Graphics_PDF, "destination" ) );
3519
3520 env->initDefineCoreFunction( new Lang::Core_textrenderingmode( Lang::THE_NAMESPACE_Shapes_Text, "textmode" ) );
3521 env->initDefineCoreFunction( new Lang::Core_manualkern( Lang::THE_NAMESPACE_Shapes_Text, "kerning" ) );
3522 env->initDefineCoreFunction( new Lang::Core_automatickern( Lang::THE_NAMESPACE_Shapes_Text, "kern" ) );
3523
3524 env->initDefineCoreFunction( new Lang::Core_importFont( Lang::THE_NAMESPACE_Shapes_Text, "font" ) );
3525
3526 env->initDefineCoreFunction( new Lang::Core_Unicode( Lang::THE_NAMESPACE_Shapes_String, "Unicode" ) );
3527 env->initDefineCoreFunction( new Lang::Core_AdobeGlyphList( Lang::THE_NAMESPACE_Shapes_String, "AdobeGlyphList" ) );
3528 }
Graphics language