?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updating the changelog in the VERSION file, and version_sync.
[shapes.git] / source / coreconstruct.cc
blob4c1c14601b856f05c0cba99c4fe4957c3603df1a
1 /* This file is part of Shapes.
2 *
3 * Shapes is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 3 of the License, or
6 * any later version.
7 *
8 * Shapes is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with Shapes. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Copyright 2008 Henrik Tidefelt
17 */
18
19 #include <cmath>
20
21 #include "Shapes_Helpers_decls.h"
22
23 #include "shapescore.h"
24 #include "globals.h"
25 #include "shapesexceptions.h"
26 #include "consts.h"
27 #include "simplepdfi.h"
28 #include "simplepdfo.h"
29 #include "astfun.h"
30 #include "tagtypes.h"
31 #include "multipage.h"
32 #include "charconverters.h"
33 #include "pagecontentstates.h"
34 #include "texlabelmanager.h"
35 #include "autoonoff.h"
36 #include "timetypes.h"
37 #include "config.h"
38
39 #include <iostream>
40 #include <sstream>
41 #include <fstream>
42 #include <vector>
43 #include <stdio.h>
44 #include <ctime>
45
46 using namespace Shapes;
47
48
49 namespace Shapes
50 {
51 namespace Lang
52 {
53
54 class Core_tag : public Lang::CoreFunction
55 {
56 public:
57 Core_tag( const char * title )
58 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
59 {
60 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
61 formals_->appendEvaluatedCoreFormal( "obj", Kernel::THE_SLOT_VARIABLE );
62 formals_->appendEvaluatedCoreFormal( "transform", Kernel::THE_TRUE_VARIABLE ); // this argument means "transform if applicable"
63 formals_->appendEvaluatedCoreFormal( "draw", Kernel::THE_TRUE_VARIABLE ); // this argument means "draw if applicable"
64 }
65
66 virtual void
67 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
68 {
69 args.applyDefaults( );
70
71 typedef const Lang::Symbol KeyType;
72 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( title_, args, 0, callLoc );
73 bool tryTransform = Helpers::down_cast_CoreArgument< const Lang::Boolean >( title_, args, 2, callLoc )->val_;
74 bool tryDraw = Helpers::down_cast_CoreArgument< const Lang::Boolean >( title_, args, 3, callLoc )->val_;
75
76 if( tryDraw && ! tryTransform )
77 {
78 throw Exceptions::CoreOutOfRange( title_, args, 3, "A tagged object which does not transform cannot be drawn." );
79 }
80
81 size_t argsi = 1;
82
83 if( tryDraw )
84 {
85 try
86 {
87 typedef const Lang::Drawable2D ArgType;
88
89 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
90
91 Kernel::ContRef cont = evalState->cont_;
92 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedDrawable2D( key, obj ) ),
93 evalState );
94 return;
95 }
96 catch( const NonLocalExit::NotThisType & ball )
97 {
98 // Never mind, see below
99 }
100
101 try
102 {
103 typedef const Lang::Drawable3D ArgType;
104
105 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
106
107 Kernel::ContRef cont = evalState->cont_;
108 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedDrawable3D( key, obj ) ),
109 evalState );
110 return;
111 }
112 catch( const NonLocalExit::NotThisType & ball )
113 {
114 // Never mind, see below
115 }
116 }
117
118 if( tryTransform )
119 {
120 try
121 {
122 typedef const Lang::Geometric2D ArgType;
123
124 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
125
126 Kernel::ContRef cont = evalState->cont_;
127 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedGeometric2D( key, obj ) ),
128 evalState );
129 return;
130 }
131 catch( const NonLocalExit::NotThisType & ball )
132 {
133 // Never mind, see below
134 }
135
136 try
137 {
138 typedef const Lang::Geometric3D ArgType;
139
140 RefCountPtr< ArgType > obj = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( argsi ) );
141
142 Kernel::ContRef cont = evalState->cont_;
143 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedGeometric3D( key, obj ) ),
144 evalState );
145 return;
146 }
147 catch( const NonLocalExit::NotThisType & ball )
148 {
149 // Never mind, see below
150 }
151 }
152
153 {
154 // As a last resort, we tag any value.
155 // We return a Drawable2D. Use immerse to make it 3D.
156 Kernel::ContRef cont = evalState->cont_;
157 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::TaggedValue2D( key, args.getValue( argsi ) ) ),
158 evalState );
159 }
160 }
161 };
162
163 // This function is in this file just because it i so related to Core_tag.
164 class Core_find : public Lang::CoreFunction
165 {
166 public:
167 Core_find( const char * title )
168 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
169 {
170 formals_->appendEvaluatedCoreFormal( "container", Kernel::THE_SLOT_VARIABLE );
171 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
172 }
173
174 virtual void
175 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
176 {
177 args.applyDefaults( );
178
179 typedef const Lang::Symbol KeyType;
180 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( title_, args, 1, callLoc );
181
182 size_t argsi = 0;
183
184 try
185 {
186 typedef const Lang::Drawable2D ContainerType;
187
188 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
189
190 if( ! container->findOneTag( evalState, key->getKey( ), Lang::THE_2D_IDENTITY ) )
191 {
192 throw Exceptions::CoreOutOfRange( title_, args, 1, "Key not found." );
193 }
194 return;
195 }
196 catch( const NonLocalExit::NotThisType & ball )
197 {
198 // Never mind, see below
199 }
200
201 try
202 {
203 typedef const Lang::Drawable3D ContainerType;
204
205 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
206
207 if( ! container->findOneTag( evalState, key->getKey( ), Lang::THE_3D_IDENTITY ) )
208 {
209 throw Exceptions::CoreOutOfRange( title_, args, 1, "Key not found." );
210 }
211 return;
212 }
213 catch( const NonLocalExit::NotThisType & ball )
214 {
215 // Never mind, see below
216 }
217
218 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, argsi, Helpers::typeSetString( Lang::Drawable2D::staticTypeName( ), Lang::Drawable3D::staticTypeName( ) ) );
219 }
220 };
221
222 // This function is in this file just because it i so related to Core_tag.
223 class Core_findall : public Lang::CoreFunction
224 {
225 public:
226 Core_findall( const char * title )
227 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
228 {
229 formals_->appendEvaluatedCoreFormal( "container", Kernel::THE_SLOT_VARIABLE );
230 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
231 }
232
233 virtual void
234 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
235 {
236 args.applyDefaults( );
237
238 typedef const Lang::Symbol KeyType;
239 RefCountPtr< KeyType > key = Helpers::down_cast_CoreArgument< KeyType >( title_, args, 1, callLoc );
240
241 size_t argsi = 0;
242
243 try
244 {
245 typedef const Lang::Drawable2D ContainerType;
246
247 RefCountPtr< ContainerType > container = Helpers::try_cast_CoreArgument< ContainerType >( args.getValue( argsi ) );
248
249 std::vector< Kernel::ValueRef > * dst = new std::vector< Kernel::ValueRef >;
250 container->findTags( dst, evalState->dyn_, key->getKey( ), Lang::THE_2D_IDENTITY );
251
252 Kernel::ContRef cont = evalState->cont_;
253 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::VectorFunction( dst ) ),
254 evalState );
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 std::vector< Kernel::ValueRef > * dst = new std::vector< Kernel::ValueRef >;
269 container->findTags( dst, evalState->dyn_, key->getKey( ), Lang::THE_3D_IDENTITY );
270
271 Kernel::ContRef cont = evalState->cont_;
272 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::VectorFunction( dst ) ),
273 evalState );
274 return;
275 }
276 catch( const NonLocalExit::NotThisType & ball )
277 {
278 // Never mind, see below
279 }
280
281 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, argsi, Helpers::typeSetString( Lang::Drawable2D::staticTypeName( ), Lang::Drawable3D::staticTypeName( ) ) );
282 }
283 };
284
285 class Core_phong : public Lang::CoreFunction
286 {
287 public:
288 Core_phong( const char * title ) : CoreFunction( title ) { }
289 virtual void
290 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
291 {
292 const size_t ARITY = 1;
293 CHECK_ARITY( args, ARITY, title_ );
294
295 typedef const Lang::Float ArgType;
296 double exponent = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc )->val_;
297 if( exponent < 0 )
298 {
299 throw Exceptions::CoreOutOfRange( title_, args, 0, "The Phong exponent should be greater than 0." );
300 }
301
302 Kernel::ContRef cont = evalState->cont_;
303 cont->takeValue( Kernel::ValueRef( new Lang::SpecularReflectionTerm( 1., exponent ) ),
304 evalState );
305 }
306 };
307
308 class Core_cons : public Lang::CoreFunction
309 {
310 public:
311 Core_cons( const char * title )
312 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), false ) )
313 {
314 formals_->appendEvaluatedCoreFormal( "car", Kernel::THE_SLOT_VARIABLE );
315 formals_->appendEvaluatedCoreFormal( "cdr", Kernel::THE_SLOT_VARIABLE );
316 }
317 virtual void
318 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
319 {
320 const size_t ARITY = 2;
321 CHECK_ARITY( args, ARITY, title_ );
322
323 Kernel::ContRef cont = evalState->cont_;
324 cont->takeValue( Kernel::ValueRef( new Lang::ConsPair( args.getHandle( 0 ),
325 args.getHandle( 1 ) ) ),
326 evalState );
327 }
328 };
329
330 class Core_list : public Lang::CoreFunction
331 {
332 public:
333 Core_list( const char * title ) : CoreFunction( title ) { }
334 virtual void
335 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
336 {
337 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
338 if( ! args.empty( ) )
339 {
340 for( size_t i = args.size( ) - 1; ; --i )
341 {
342 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( args.getHandle( i ), res ) );
343 if( i == 0 )
344 {
345 break;
346 }
347 }
348 }
349
350 Kernel::ContRef cont = evalState->cont_;
351 cont->takeValue( res,
352 evalState );
353 }
354 };
355
356 class Core_unlist : public Lang::CoreFunction
357 {
358 Kernel::UnnamedStructureFactory argListFactory_;
359 public:
360 Core_unlist( const char * title ) : CoreFunction( title ) { }
361 virtual void
362 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
363 {
364 const size_t ARITY = 1;
365 CHECK_ARITY( args, ARITY, title_ );
366
367 typedef const Lang::SingleList ArgType;
368
369 Kernel::ContRef cont = evalState->cont_;
370 cont->takeValue( argListFactory_.build( Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc ) ),
371 evalState );
372 }
373 };
374
375 class Core_isnull : public Lang::CoreFunction
376 {
377 public:
378 Core_isnull( const char * title ) : CoreFunction( title ) { }
379 virtual void
380 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
381 {
382 const size_t ARITY = 1;
383 CHECK_ARITY( args, ARITY, title_ );
384
385 RefCountPtr< const Lang::Value > aUntyped = args.getValue( 0 );
386
387 Kernel::ContRef cont = evalState->cont_;
388 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::Boolean( dynamic_cast< const Lang::SingleListNull * >( args.getValue( 0 ).getPtr( ) ) != 0 ) ),
389 evalState );
390 }
391 };
392
393 class Core_range : public Lang::CoreFunction
394 {
395 public:
396 Core_range( const char * title )
397 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
398 {
399 formals_->appendEvaluatedCoreFormal( "begin", Kernel::THE_VOID_VARIABLE );
400 formals_->appendEvaluatedCoreFormal( "end", Kernel::THE_VOID_VARIABLE );
401 formals_->appendEvaluatedCoreFormal( "step", Kernel::THE_VOID_VARIABLE );
402 formals_->appendEvaluatedCoreFormal( "count", Kernel::THE_VOID_VARIABLE );
403 }
404 virtual void
405 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
406 {
407 typedef const Lang::Integer CountType;
408
409 args.applyDefaults( );
410
411 try
412 {
413 typedef const Lang::Integer ArgType;
414
415 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 0 ), true );
416 RefCountPtr< ArgType > endPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 1 ), true );
417 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
418 {
419 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", title_, callLoc );
420 }
421 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 2, callLoc, true );
422 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( title_, args, 3, callLoc, true );
423
424 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
425 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
426 {
427 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", title_, callLoc );
428 }
429
430 ArgType::ValueType begin = 0;
431 ArgType::ValueType end = -1;
432 ArgType::ValueType step = 1;
433 if( beginPtr == NullPtr< ArgType >( ) )
434 {
435 if( stepPtr != NullPtr< ArgType >( ) )
436 {
437 step = stepPtr->val_;
438 }
439 if( countPtr == NullPtr< CountType >( ) )
440 {
441 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of integers when <begin> is omitted.", title_, callLoc );
442 }
443 if( countPtr->val_ < 2 )
444 {
445 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
446 }
447 end = endPtr->val_;
448 begin = end - step * ( countPtr->val_ - 1 );
449 }
450 else if( endPtr == NullPtr< ArgType >( ) )
451 {
452 if( stepPtr != NullPtr< ArgType >( ) )
453 {
454 step = stepPtr->val_;
455 }
456 if( countPtr == NullPtr< CountType >( ) )
457 {
458 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of integers when <end> is omitted.", title_, callLoc );
459 }
460 if( countPtr->val_ < 2 )
461 {
462 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
463 }
464 begin = beginPtr->val_;
465 end = begin + step * ( countPtr->val_ - 1 );
466 }
467 else
468 {
469 if( countPtr != NullPtr< CountType >( ) )
470 {
471 throw Exceptions::CoreRequirement( "It is an error to provide the <count> arguments when constructing a range of integers from <begin> to <end>.", title_, args.getLoc( 3 ) );
472 }
473
474 begin = beginPtr->val_;
475 end = endPtr->val_;
476 if( stepPtr != NullPtr< ArgType >( ) )
477 {
478 step = stepPtr->val_;
479 }
480 }
481
482 std::list< ArgType::ValueType > tmp;
483
484 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
485 if( step > 0 )
486 {
487 for( ArgType::ValueType x = begin; x <= end; x += step )
488 {
489 tmp.push_back( x );
490 }
491 }
492 else if( step < 0 )
493 {
494 for( ArgType::ValueType x = begin; x >= end; x += step )
495 {
496 tmp.push_back( x );
497 }
498 }
499 else
500 {
501 throw Exceptions::CoreOutOfRange( title_, args, 2, "Step size must not be zero." );
502 }
503
504 while( ! tmp.empty( ) )
505 {
506 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Helpers::newValHandle( new Lang::Integer( tmp.back( ) ) ),
507 res ) );
508 tmp.pop_back( );
509 }
510
511 Kernel::ContRef cont = evalState->cont_;
512 cont->takeValue( res,
513 evalState );
514 return;
515 }
516 catch( const NonLocalExit::NotThisType & ball )
517 {
518 // Never mind, see below
519 }
520
521 try
522 {
523 typedef const Lang::Float ArgType;
524
525 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 0 ), true );
526 RefCountPtr< ArgType > endPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 1 ), true );
527 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
528 {
529 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", title_, callLoc );
530 }
531 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 2, callLoc, true );
532 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( title_, args, 3, callLoc, true );
533
534 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
535 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
536 {
537 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", title_, callLoc );
538 }
539
540 double begin = 0;
541 double end = -1;
542 double step = 1;
543 bool appendEnd = false;
544 if( beginPtr == NullPtr< ArgType >( ) )
545 {
546 if( stepPtr == NullPtr< ArgType >( ) )
547 {
548 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of floats when <begin> is omitted.", title_, callLoc );
549 }
550 if( countPtr == NullPtr< CountType >( ) )
551 {
552 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of floats when <begin> is omitted.", title_, callLoc );
553 }
554 if( countPtr->val_ < 2 )
555 {
556 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
557 }
558 end = endPtr->val_;
559 step = stepPtr->val_;
560 begin = end - step * ( countPtr->val_ - 1 );
561 end -= 0.5 * step;
562 appendEnd = true;
563 }
564 else if( endPtr == NullPtr< ArgType >( ) )
565 {
566 if( stepPtr == NullPtr< ArgType >( ) )
567 {
568 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of floats when <end> is omitted.", title_, callLoc );
569 }
570 if( countPtr == NullPtr< CountType >( ) )
571 {
572 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of floats when <end> is omitted.", title_, callLoc );
573 }
574 if( countPtr->val_ < 2 )
575 {
576 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
577 }
578 begin = beginPtr->val_;
579 step = stepPtr->val_;
580 end = begin + step * ( countPtr->val_ - 0.5 );
581 }
582 else
583 {
584 // When we reach here, we know that at most one of <step> and <count> is provided.
585 if( stepPtr != NullPtr< ArgType >( ) )
586 {
587 begin = beginPtr->val_;
588 end = endPtr->val_;
589 step = stepPtr->val_;
590 }
591 else if( countPtr != NullPtr< CountType >( ) )
592 {
593 if( countPtr->val_ < 2 )
594 {
595 throw Exceptions::CoreOutOfRange( title_, args, 3, "The number of elements must be at least 2." );
596 }
597 begin = beginPtr->val_;
598 end = endPtr->val_;
599 step = ( end - begin ) / ( countPtr->val_ - 1 );
600 end -= 0.5 * step;
601 appendEnd = true;
602 }
603 else
604 {
605 begin = beginPtr->val_;
606 end = endPtr->val_;
607 }
608 }
609
610 std::list< double > tmp;
611
612 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
613 if( step > 0 )
614 {
615 for( double x = begin; x < end; x += step )
616 {
617 tmp.push_back( x );
618 }
619 }
620 else if( step < 0 )
621 {
622 for( double x = begin; x > end; x += step )
623 {
624 tmp.push_back( x );
625 }
626 }
627 else
628 {
629 throw Exceptions::CoreOutOfRange( title_, args, 2, "Step size must not be zero." );
630 }
631 if( appendEnd )
632 {
633 tmp.push_back( endPtr->val_ );
634 }
635
636 while( ! tmp.empty( ) )
637 {
638 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Helpers::newValHandle( new Lang::Float( tmp.back( ) ) ),
639 res ) );
640 tmp.pop_back( );
641 }
642
643 Kernel::ContRef cont = evalState->cont_;
644 cont->takeValue( res,
645 evalState );
646 return;
647 }
648 catch( const NonLocalExit::NotThisType & ball )
649 {
650 // Never mind, see below
651 }
652
653 try
654 {
655 typedef const Lang::Length ArgType;
656
657 RefCountPtr< ArgType > beginPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 0 ), true );
658 RefCountPtr< ArgType > endPtr = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( 1 ), true );
659 if( beginPtr == NullPtr< ArgType >( ) && endPtr == NullPtr< ArgType >( ) )
660 {
661 throw Exceptions::CoreRequirement( "At least one of the arguments <begin> and <end> must be provided.", title_, callLoc );
662 }
663 RefCountPtr< ArgType > stepPtr = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 2, callLoc, true );
664 RefCountPtr< CountType > countPtr = Helpers::down_cast_CoreArgument< CountType >( title_, args, 3, callLoc, true );
665
666 if( beginPtr != NullPtr< ArgType >( ) && endPtr != NullPtr< ArgType >( ) &&
667 stepPtr != NullPtr< ArgType >( ) && countPtr != NullPtr< CountType >( ) )
668 {
669 throw Exceptions::CoreRequirement( "At least one of the arguments must be omitted.", title_, callLoc );
670 }
671
672 double begin = 0;
673 double end = -1;
674 double step = 1;
675 bool appendEnd = false;
676 if( beginPtr == NullPtr< ArgType >( ) )
677 {
678 if( stepPtr == NullPtr< ArgType >( ) )
679 {
680 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of lengths when <begin> is omitted.", title_, callLoc );
681 }
682 if( countPtr == NullPtr< CountType >( ) )
683 {
684 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of lengths when <begin> is omitted.", title_, callLoc );
685 }
686 if( countPtr->val_ < 2 )
687 {
688 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
689 }
690 end = endPtr->getScalar( );
691 step = stepPtr->getScalar( );
692 begin = end - step * ( countPtr->val_ - 1 );
693 end -= 0.5 * step;
694 appendEnd = true;
695 }
696 else if( endPtr == NullPtr< ArgType >( ) )
697 {
698 if( stepPtr == NullPtr< ArgType >( ) )
699 {
700 throw Exceptions::CoreRequirement( "The <step> must be provided when constructing a range of lengths when <end> is omitted.", title_, callLoc );
701 }
702 if( countPtr == NullPtr< CountType >( ) )
703 {
704 throw Exceptions::CoreRequirement( "The <count> must be provided when constructing a range of lengths when <end> is omitted.", title_, callLoc );
705 }
706 if( countPtr->val_ < 2 )
707 {
708 throw Exceptions::CoreOutOfRange( title_, args, 3, "The <count> must be at least 2." );
709 }
710 begin = beginPtr->getScalar( );
711 step = stepPtr->getScalar( );
712 end = begin + step * ( countPtr->val_ - 0.5 );
713 }
714 else
715 {
716 if( stepPtr == NullPtr< ArgType >( ) && countPtr == NullPtr< CountType >( ) )
717 {
718 throw Exceptions::CoreRequirement( "Either of the <step> and <count> arguments must be provided when constructing a range of lengths from <begin> to <end>.", title_, callLoc );
719 }
720 // When we reach here, we know that exactly one of <step> and <count> is provided.
721 if( stepPtr != NullPtr< ArgType >( ) )
722 {
723 begin = beginPtr->getScalar( );
724 end = endPtr->getScalar( );
725 step = stepPtr->getScalar( );
726 }
727 else
728 {
729 begin = beginPtr->getScalar( );
730 end = endPtr->getScalar( );
731 // We know countPtr is not null here.
732 if( countPtr->val_ < 2 )
733 {
734 throw Exceptions::CoreOutOfRange( title_, args, 3, "The number of elements must be at least 2." );
735 }
736 step = ( end - begin ) / ( countPtr->val_ - 1 );
737 end -= 0.5 * step;
738 appendEnd = true;
739 }
740 }
741
742
743 std::list< double > tmp;
744
745 RefCountPtr< const Lang::SingleList > res = Lang::THE_CONS_NULL;
746 if( step > 0 )
747 {
748 for( double x = begin; x < end; x += step )
749 {
750 tmp.push_back( x );
751 }
752 }
753 else if( step < 0 )
754 {
755 for( double x = begin; x > end; x += step )
756 {
757 tmp.push_back( x );
758 }
759 }
760 else
761 {
762 throw Exceptions::CoreOutOfRange( title_, args, 2, "Step size must not be zero." );
763 }
764 if( appendEnd )
765 {
766 tmp.push_back( endPtr->getScalar( ) );
767 }
768
769 while( ! tmp.empty( ) )
770 {
771 res = RefCountPtr< const Lang::SingleList >( new Lang::SingleListPair( Helpers::newValHandle( new Lang::Length( tmp.back( ) ) ),
772 res ) );
773 tmp.pop_back( );
774 }
775
776 Kernel::ContRef cont = evalState->cont_;
777 cont->takeValue( res,
778 evalState );
779 return;
780 }
781 catch( const NonLocalExit::NotThisType & ball )
782 {
783 // Never mind, see below
784 }
785
786 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, 0, Helpers::typeSetString( Lang::Integer::staticTypeName( ), Lang::Float::staticTypeName( ), Lang::Length::staticTypeName( ) ) );
787 }
788 };
789
790 class Core_affinetransform : public Lang::CoreFunction
791 {
792 public:
793 Core_affinetransform( const char * title ) : CoreFunction( title ) { }
794 virtual void
795 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
796 {
797 const size_t ARITY = 3;
798 CHECK_ARITY( args, ARITY, title_ );
799
800 typedef const Lang::FloatPair ArgType0;
801 typedef const Lang::FloatPair ArgType1;
802 typedef const Lang::Coords2D ArgType2;
803
804 RefCountPtr< ArgType0 > argx = Helpers::down_cast_CoreArgument< ArgType0 >( title_, args, 0, callLoc );
805 RefCountPtr< ArgType1 > argy = Helpers::down_cast_CoreArgument< ArgType1 >( title_, args, 1, callLoc );
806 RefCountPtr< ArgType2 > arg1 = Helpers::down_cast_CoreArgument< ArgType2 >( title_, args, 2, callLoc );
807
808 Kernel::ContRef cont = evalState->cont_;
809 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( argx->x_, argx->y_, argy->x_, argy->y_, arg1->x_.get( ), arg1->y_.get( ) ) ),
810 evalState );
811 }
812 };
813
814 class Core_affinetransform3D : public Lang::CoreFunction
815 {
816 public:
817 Core_affinetransform3D( const char * title ) : CoreFunction( title ) { }
818 virtual void
819 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
820 {
821 const size_t ARITY = 4;
822 CHECK_ARITY( args, ARITY, title_ );
823
824 typedef const Lang::FloatTriple ArgType0;
825 typedef const Lang::FloatTriple ArgType1;
826 typedef const Lang::FloatTriple ArgType2;
827 typedef const Lang::Coords3D ArgType3;
828
829 RefCountPtr< ArgType0 > argx = Helpers::down_cast_CoreArgument< ArgType0 >( title_, args, 0, callLoc );
830 RefCountPtr< ArgType1 > argy = Helpers::down_cast_CoreArgument< ArgType1 >( title_, args, 1, callLoc );
831 RefCountPtr< ArgType2 > argz = Helpers::down_cast_CoreArgument< ArgType2 >( title_, args, 2, callLoc );
832 RefCountPtr< ArgType3 > arg1 = Helpers::down_cast_CoreArgument< ArgType3 >( title_, args, 3, callLoc );
833
834 Kernel::ContRef cont = evalState->cont_;
835 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( argx->x_, argx->y_, argx->z_,
836 argy->x_, argy->y_, argy->z_,
837 argz->x_, argz->y_, argz->z_,
838 arg1->x_.get( ), arg1->y_.get( ), arg1->z_.get( ) ) ),
839 evalState );
840 }
841 };
842
843 class Core_shift : public Lang::CoreFunction
844 {
845 public:
846 Core_shift( const char * title ) : CoreFunction( title ) { }
847 virtual void
848 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
849 {
850 const size_t ARITY = 1;
851 CHECK_ARITY( args, ARITY, title_ );
852
853 Kernel::ContRef cont = evalState->cont_;
854
855 size_t i = 0;
856 try
857 {
858 typedef const Lang::Coords2D ArgType1;
859 RefCountPtr< ArgType1 > arg1 = Helpers::try_cast_CoreArgument< ArgType1 >( args.getValue( i ) );
860 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( 1, 0, 0, 1, arg1->x_.get( ), arg1->y_.get( ) ) ),
861 evalState );
862 return;
863 }
864 catch( const NonLocalExit::NotThisType & ball )
865 {
866 // Never mind, see below
867 }
868
869 try
870 {
871 typedef const Lang::Coords3D ArgType1;
872 RefCountPtr< ArgType1 > arg1 = Helpers::try_cast_CoreArgument< ArgType1 >( args.getValue( i ) );
873 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( ) ) ),
874 evalState );
875 return;
876 }
877 catch( const NonLocalExit::NotThisType & ball )
878 {
879 // Never mind, see below
880 }
881
882 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, i, Helpers::typeSetString( Lang::Coords2D::staticTypeName( ), Lang::Coords3D::staticTypeName( ) ) );
883 }
884 };
885
886 class Core_rotate : public Lang::CoreFunction
887 {
888 public:
889 Core_rotate( const char * title )
890 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
891 {
892 formals_->appendEvaluatedCoreFormal( "angle", Kernel::THE_SLOT_VARIABLE );
893 }
894 virtual void
895 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
896 {
897 args.applyDefaults( );
898
899 size_t i = 0;
900
901 typedef const Lang::Float ArgType1;
902 RefCountPtr< ArgType1 > arg1 = Helpers::down_cast_CoreArgument< ArgType1 >( title_, args, i, callLoc );
903
904 double c = cos( arg1->val_ );
905 double s = sin( arg1->val_ );
906 Kernel::ContRef cont = evalState->cont_;
907 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( c, s, -s, c, 0, 0 ) ),
908 evalState );
909 }
910 };
911
912 class Core_rotate3d : public Lang::CoreFunction
913 {
914 public:
915 Core_rotate3d( const char * title )
916 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
917 {
918 formals_->appendEvaluatedCoreFormal( "dir", Kernel::THE_SLOT_VARIABLE );
919 formals_->appendEvaluatedCoreFormal( "angle", Kernel::THE_SLOT_VARIABLE );
920 }
921 virtual void
922 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
923 {
924 args.applyDefaults( );
925
926 size_t i = 0;
927
928 typedef const Lang::FloatTriple ArgType1;
929 RefCountPtr< ArgType1 > dir = Helpers::down_cast_CoreArgument< ArgType1 >( title_, args, i, callLoc );
930 if( dir->x_ == 0 && dir->y_ == 0 && dir->z_ == 0 )
931 {
932 throw Exceptions::CoreOutOfRange( title_, args, i, "The rotation direction is degenerate, that is (0,0,0)." );
933 }
934
935 ++i;
936
937 typedef const Lang::Float ArgType2;
938 RefCountPtr< ArgType2 > angle = Helpers::down_cast_CoreArgument< ArgType2 >( title_, args, i, callLoc );
939
940 double r = sqrt( dir->x_ * dir->x_ + dir->y_ * dir->y_ + dir->z_ * dir->z_ );
941 double x = dir->x_ / r;
942 double y = dir->y_ / r;
943 double z = dir->z_ / r;
944 double x2 = x * x;
945 double y2 = y * y;
946 double z2 = z * z;
947 double c = cos( angle->val_ );
948 double s = sin( angle->val_ );
949 Kernel::ContRef cont = evalState->cont_;
950 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( x2+(y2+z2)*c, x*y*(1-c)+z*s, x*z*(1-c)-y*s,
951 x*y*(1-c)-z*s, y2+(x2+z2)*c, y*z*(1-c)+x*s,
952 x*z*(1-c)+y*s, y*z*(1-c)-x*s, z2+(x2+y2)*c,
953 0, 0, 0 ) ),
954 evalState );
955 }
956 };
957
958 class Core_scale : public Lang::CoreFunction
959 {
960 public:
961 Core_scale( const char * title )
962 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
963 {
964 Kernel::VariableHandle one( new Kernel::Variable( RefCountPtr< const Lang::Value >( new Lang::Float( 1 ) ) ) );
965
966 formals_->appendEvaluatedCoreFormal( "r", one );
967 formals_->appendEvaluatedCoreFormal( "x", one );
968 formals_->appendEvaluatedCoreFormal( "y", one );
969 }
970 virtual void
971 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
972 {
973 args.applyDefaults( );
974
975 typedef const Lang::Float ArgType;
976 RefCountPtr< ArgType > argr = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc );
977 RefCountPtr< ArgType > argx = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 1, callLoc );
978 RefCountPtr< ArgType > argy = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 2, callLoc );
979
980 Kernel::ContRef cont = evalState->cont_;
981 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( argr->val_ * argx->val_, 0,
982 0, argr->val_ * argy->val_,
983 0, 0 ) ),
984 evalState );
985 }
986 };
987
988 class Core_scale3d : public Lang::CoreFunction
989 {
990 public:
991 Core_scale3d( const char * title )
992 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
993 {
994 Kernel::VariableHandle one( new Kernel::Variable( RefCountPtr< const Lang::Value >( new Lang::Float( 1 ) ) ) );
995
996 formals_->appendEvaluatedCoreFormal( "r", one );
997 formals_->appendEvaluatedCoreFormal( "x", one );
998 formals_->appendEvaluatedCoreFormal( "y", one );
999 formals_->appendEvaluatedCoreFormal( "z", one );
1000 }
1001 virtual void
1002 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1003 {
1004 args.applyDefaults( );
1005
1006 typedef const Lang::Float ArgType;
1007 RefCountPtr< ArgType > argr = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc );
1008 RefCountPtr< ArgType > argx = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 1, callLoc );
1009 RefCountPtr< ArgType > argy = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 2, callLoc );
1010 RefCountPtr< ArgType > argz = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 3, callLoc );
1011
1012 Kernel::ContRef cont = evalState->cont_;
1013 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( argr->val_ * argx->val_, 0, 0,
1014 0, argr->val_ * argy->val_, 0,
1015 0, 0, argr->val_ * argz->val_,
1016 0, 0, 0 ) ),
1017 evalState );
1018 }
1019 };
1020
1021 class Core_inverse : public Lang::CoreFunction
1022 {
1023 public:
1024 Core_inverse( const char * title ) : CoreFunction( title ) { }
1025 virtual void
1026 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1027 {
1028 const size_t ARITY = 1;
1029 CHECK_ARITY( args, ARITY, title_ );
1030
1031 {
1032 typedef const Lang::Transform2D ArgType;
1033 ArgType * tf = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1034 if( tf != 0 )
1035 {
1036 double det = tf->xx_ * tf->yy_ - tf->xy_ * tf->yx_;
1037 if( fabs( det ) < Computation::SINGULAR_TRANSFORM_LIMIT )
1038 {
1039 throw Exceptions::CoreOutOfRange( title_, args, 0, "Singular transforms cannot be inverted." );
1040 }
1041 double idet = 1 / det;
1042 double ixx = idet * tf->yy_;
1043 double ixy = - idet * tf->xy_;
1044 double iyx = - idet * tf->yx_;
1045 double iyy = idet * tf->xx_;
1046 Kernel::ContRef cont = evalState->cont_;
1047 cont->takeValue( Kernel::ValueRef( new Lang::Transform2D( ixx, iyx,
1048 ixy, iyy,
1049 -( ixx * tf->xt_ + ixy * tf->yt_ ), -( iyx * tf->xt_ + iyy * tf->yt_ ) ) ),
1050 evalState );
1051 return;
1052 }
1053 }
1054
1055 {
1056 typedef const Lang::Transform3D ArgType;
1057 ArgType * tf = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1058 if( tf != 0 )
1059 {
1060 double det =
1061 tf->xx_ * ( tf->yy_ * tf->zz_ - tf->yz_ * tf->zy_ )
1062 - tf->xy_ * ( tf->yx_ * tf->zz_ - tf->yz_ * tf->zx_ )
1063 + tf->xz_ * ( tf->yx_ * tf->zy_ - tf->yy_ * tf->zx_ );
1064 if( fabs( det ) < Computation::SINGULAR_TRANSFORM_LIMIT )
1065 {
1066 throw Exceptions::CoreOutOfRange( title_, args, 0, "Singular transforms cannot be inverted." );
1067 }
1068 double idet = 1 / det;
1069 double ixx = idet * ( tf->yy_ * tf->zz_ - tf->yz_ * tf->zy_ );
1070 double ixy = - idet * ( tf->xy_ * tf->zz_ - tf->xz_ * tf->zy_ );
1071 double ixz = idet * ( tf->xy_ * tf->yz_ - tf->xz_ * tf->yy_ );
1072 double iyx = - idet * ( tf->yx_ * tf->zz_ - tf->yz_ * tf->zx_ );
1073 double iyy = idet * ( tf->xx_ * tf->zz_ - tf->xz_ * tf->zx_ );
1074 double iyz = - idet * ( tf->xx_ * tf->yz_ - tf->xz_ * tf->yx_ );
1075 double izx = idet * ( tf->yx_ * tf->zy_ - tf->yy_ * tf->zx_ );
1076 double izy = - idet * ( tf->xx_ * tf->zy_ - tf->xy_ * tf->zx_ );
1077 double izz = idet * ( tf->xx_ * tf->yy_ - tf->xy_ * tf->yx_ );
1078 Kernel::ContRef cont = evalState->cont_;
1079 cont->takeValue( Kernel::ValueRef( new Lang::Transform3D( ixx, iyx, izx,
1080 ixy, iyy, izy,
1081 ixz, iyz, izz,
1082 -( ixx * tf->xt_ + ixy * tf->yt_ + ixz * tf->zt_ ),
1083 -( iyx * tf->xt_ + iyy * tf->yt_ + iyz * tf->zt_ ),
1084 -( izx * tf->xt_ + izy * tf->yt_ + izz * tf->zt_ ) ) ),
1085 evalState );
1086 return;
1087 }
1088 }
1089
1090 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, 0, Helpers::typeSetString( Lang::Transform2D::staticTypeName( ), Lang::Transform3D::staticTypeName( ) ) );
1091 }
1092 };
1093
1094 class Core_formxo : public Lang::CoreFunction
1095 {
1096 public:
1097 Core_formxo( const char * title ) : CoreFunction( title ) { }
1098 virtual void
1099 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1100 {
1101 const size_t ARITY = 1;
1102 CHECK_ARITY( args, ARITY, title_ );
1103
1104 typedef const Lang::Drawable2D ArgType;
1105 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc );
1106
1107 RefCountPtr< const Lang::ElementaryPath2D > theBBox = arg->bbox( Lang::Drawable2D::BOUNDING );
1108 Concrete::Coords2D llcorner( 0, 0 );
1109 Concrete::Coords2D urcorner( 0, 0 );
1110 if( ! theBBox->boundingRectangle( & llcorner, & urcorner ) )
1111 {
1112 std::string strTitle( title_ );
1113 throw Exceptions::InternalError( strrefdup( strTitle + ": The object has no bounding box!" ) );
1114 }
1115
1116
1117 RefCountPtr< SimplePDF::PDF_Stream_out > form;
1118 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( form, & Kernel::theIndirectObjectCount );
1119
1120 RefCountPtr< SimplePDF::PDF_Resources > resources;
1121 (*form)[ "Resources" ] = SimplePDF::indirect( resources, & Kernel::theIndirectObjectCount );
1122
1123 (*form)[ "Subtype" ] = SimplePDF::newName( "Form" );
1124 (*form)[ "FormType" ] = SimplePDF::newInt( 1 );
1125 (*form)[ "BBox" ] = RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( llcorner.x_.offtype< 1, 0 >( ), llcorner.y_.offtype< 1, 0 >( ),
1126 urcorner.x_.offtype< 1, 0 >( ), urcorner.y_.offtype< 1, 0 >( ) ) );
1127
1128 /* There's a possibility of adding a transformation matrix entry in the dictionary here, but it is not used, not even
1129 * for transformed drawables.
1130 */
1131 // (*markForm)[ "Matrix" ] = RefCountPtr<PDF_Object>( new PDF_Vector( 1, 0, 0, 1, -30, -30 ) );
1132
1133 Kernel::PageContentStates pdfState( resources );
1134 arg->shipout( form->data, & pdfState, Lang::Transform2D( 1, 0, 0, 1, 0, 0 ) );
1135
1136
1137 Lang::XObject * res = new Lang::XObject( indirection,
1138 theBBox );
1139 res->setDebugStr( "user form" );
1140 Kernel::ContRef cont = evalState->cont_;
1141 cont->takeValue( Kernel::ValueRef( res ),
1142 evalState );
1143 }
1144 };
1145
1146 class Core_transparencygroup : public Lang::CoreFunction
1147 {
1148 public:
1149 Core_transparencygroup( const char * title )
1150 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1151 {
1152 formals_->appendEvaluatedCoreFormal( "content", Kernel::THE_SLOT_VARIABLE );
1153 formals_->appendEvaluatedCoreFormal( "isolated", Kernel::THE_FALSE_VARIABLE );
1154 formals_->appendEvaluatedCoreFormal( "knockout", Kernel::THE_FALSE_VARIABLE );
1155 }
1156 virtual void
1157 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1158 {
1159 args.applyDefaults( );
1160
1161 typedef const Lang::Group2D ArgType0;
1162 typedef const Lang::Boolean ArgType1;
1163 typedef const Lang::Boolean ArgType2;
1164 RefCountPtr< ArgType0 > content = Helpers::down_cast_CoreArgument< ArgType0 >( title_, args, 0, callLoc );
1165 RefCountPtr< ArgType1 > isolated = Helpers::down_cast_CoreArgument< ArgType1 >( title_, args, 1, callLoc );
1166 RefCountPtr< ArgType2 > knockout = Helpers::down_cast_CoreArgument< ArgType2 >( title_, args, 2, callLoc );
1167
1168 RefCountPtr< const Lang::ColorSpace > blendSpace = evalState->dyn_->getBlendSpace( );
1169
1170 Kernel::ContRef cont = evalState->cont_;
1171 cont->takeValue( Helpers::newTransparencyGroup( content, isolated->val_, knockout->val_, blendSpace ),
1172 evalState );
1173 }
1174 };
1175
1176 class Core_vector : public Lang::CoreFunction
1177 {
1178 public:
1179 Core_vector( const char * title ) : CoreFunction( title ) { }
1180 virtual void
1181 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1182 {
1183 std::vector< RefCountPtr< const Lang::Value > > * res = new std::vector< RefCountPtr< const Lang::Value > >;
1184 res->reserve( args.size( ) );
1185
1186 for( size_t i = 0; i != args.size( ); ++i )
1187 {
1188 res->push_back( args.getValue( i ) );
1189 }
1190
1191 Kernel::ContRef cont = evalState->cont_;
1192 cont->takeValue( Kernel::ValueRef( new Lang::VectorFunction( res ) ),
1193 evalState );
1194 }
1195 };
1196
1197 class Core_interpolate : public Lang::CoreFunction
1198 {
1199 public:
1200 Core_interpolate( const char * title )
1201 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1202 {
1203 formals_->appendEvaluatedCoreFormal( "function", Kernel::THE_SLOT_VARIABLE );
1204 formals_->appendEvaluatedCoreFormal( "domain", Kernel::THE_SLOT_VARIABLE );
1205 formals_->appendEvaluatedCoreFormal( "size", Kernel::THE_SLOT_VARIABLE );
1206 formals_->appendEvaluatedCoreFormal( "range", Kernel::THE_SLOT_VARIABLE );
1207 formals_->appendEvaluatedCoreFormal( "encode", Kernel::THE_VOID_VARIABLE );
1208 formals_->appendEvaluatedCoreFormal( "decode", Kernel::THE_VOID_VARIABLE );
1209 }
1210 virtual void
1211 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1212 {
1213 args.applyDefaults( );
1214
1215 throw Exceptions::NotImplemented( "Core_interpolate::call" );
1216 }
1217 };
1218
1219 class Core_importPDFpages : public Lang::CoreFunction
1220 {
1221 public:
1222 Core_importPDFpages( const char * title ) : CoreFunction( title ) { }
1223 virtual void
1224 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1225 {
1226 const size_t ARITY = 1;
1227 CHECK_ARITY( args, ARITY, title_ );
1228
1229 typedef const Lang::String ArgType;
1230 RefCountPtr< ArgType > arg = Helpers::down_cast_CoreArgument< ArgType >( title_, args, 0, callLoc );
1231
1232 RefCountPtr< std::ifstream > iFile( new std::ifstream( arg->val_.getPtr( ) ) );
1233 if( ! iFile->good( ) )
1234 {
1235 std::ostringstream msg;
1236 msg << "Failed to open file for input: " << arg->val_.getPtr( ) ;
1237 throw Exceptions::CoreOutOfRange( title_, args, 0, strrefdup( msg ) );
1238 }
1239 RefCountPtr< SimplePDF::PDF_in > pdfi( new SimplePDF::PDF_in( iFile ) );
1240
1241 RefCountPtr< const std::vector< RefCountPtr< const Lang::XObject > > > typedRes = RefCountPtr< const std::vector< RefCountPtr< const Lang::XObject > > >( NullPtr< std::vector< RefCountPtr< const Lang::XObject > > >( ) );
1242 try
1243 {
1244 typedRes = Kernel::thePDFImporter.addPagesAsXObjects( pdfi );
1245 }
1246 catch( const char * ball )
1247 {
1248 throw Exceptions::InternalError( strrefdup( ( std::string( "An error occurred while importing " ) + arg->val_.getPtr( ) + ": " + ball ).c_str( ) ) );
1249 }
1250
1251 std::vector< RefCountPtr< const Lang::Value > > * untypedRes = new std::vector< RefCountPtr< const Lang::Value > >;
1252 untypedRes->reserve( typedRes->size( ) );
1253 typedef typeof *typedRes ListType;
1254 for( ListType::const_iterator i = typedRes->begin( ); i != typedRes->end( ); ++i )
1255 {
1256 untypedRes->push_back( *i );
1257 }
1258
1259 Kernel::ContRef cont = evalState->cont_;
1260 cont->takeValue( Kernel::ValueRef( new Lang::VectorFunction( untypedRes ) ),
1261 evalState );
1262 }
1263 };
1264
1265 namespace Implementation
1266 {
1267 double
1268 svg_path_strtod( const char ** src )
1269 {
1270 const char * start = *src;
1271 char * endp;
1272 double res = strtod( start, & endp );
1273 *src = endp;
1274 if( **src != ' ' )
1275 {
1276 for( ; *start == ' '; ++start )
1277 ;
1278 throw std::string( start, strchr( start, ' ' ) - start );
1279 }
1280 return res;
1281 }
1282 }
1283 class Core_svg_path : public Lang::CoreFunction
1284 {
1285 public:
1286 Core_svg_path( const char * title )
1287 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1288 {
1289 formals_->appendEvaluatedCoreFormal( "d", Kernel::THE_SLOT_VARIABLE );
1290 formals_->appendEvaluatedCoreFormal( "xunit", Helpers::newValHandle( new Lang::Length( Concrete::Length( 1 ) ) ) );
1291 formals_->appendEvaluatedCoreFormal( "yunit", Helpers::newValHandle( new Lang::Length( Concrete::Length( 1 ) ) ) );
1292 formals_->appendEvaluatedCoreFormal( "multi", Kernel::THE_VOID_VARIABLE );
1293 formals_->appendEvaluatedCoreFormal( "singletons", Kernel::THE_TRUE_VARIABLE );
1294 }
1295 virtual void
1296 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1297 {
1298 args.applyDefaults( );
1299
1300 size_t argsi = 0;
1301 typedef const Lang::String StrType;
1302 RefCountPtr< StrType > arg = Helpers::down_cast_CoreArgument< StrType >( title_, args, argsi, callLoc );
1303
1304 typedef const Lang::Length ScaleType;
1305 ++argsi;
1306 Concrete::Length dx = Helpers::down_cast_CoreArgument< ScaleType >( title_, args, argsi, callLoc )->get( );
1307 ++argsi;
1308 Concrete::Length dy = Helpers::down_cast_CoreArgument< ScaleType >( title_, args, argsi, callLoc )->get( );
1309
1310 typedef const Lang::Boolean FlagType;
1311 ++argsi;
1312 RefCountPtr< FlagType > multi = Helpers::down_cast_CoreArgument< FlagType >( title_, args, argsi, callLoc, true );
1313 ++argsi;
1314 bool singletons = Helpers::down_cast_CoreArgument< FlagType >( title_, args, argsi, callLoc )->val_;
1315
1316 RefCountPtr< char > buf = RefCountPtr< char >( new char[ 2 * strlen( arg->val_.getPtr( ) + 1 ) ] );
1317 {
1318 /* Get rid of any whitespace that isn't a plain space, and make sure every number is terminated by whitespace.
1319 */
1320 char * dst = buf.getPtr( );
1321 for( const char * src = arg->val_.getPtr( ); *src != '\0'; ++src, ++dst )
1322 {
1323 switch( *src )
1324 {
1325 case '\t':
1326 case '\n':
1327 case ',':
1328 *dst = ' ';
1329 continue;
1330 }
1331 if( ( 'A' <= *src && *src <= 'Z' ) || ( 'a' <= *src && *src <= 'z' ) )
1332 {
1333 /* Insert whitespace before command to ensure command is not immediately following number.
1334 */
1335 *dst = ' ';
1336 ++dst;
1337 }
1338 *dst = *src;
1339 }
1340 *dst = ' ';
1341 ++dst;
1342 *dst = '\0';
1343 }
1344
1345 RefCountPtr< Lang::MultiPath2D > multiPath = RefCountPtr< Lang::MultiPath2D >( new Lang::MultiPath2D );
1346 RefCountPtr< Lang::ElementaryPath2D > elemPath = RefCountPtr< Lang::ElementaryPath2D >( NullPtr< Lang::ElementaryPath2D >( ) );
1347
1348 try
1349 {
1350 char cmd = '\0';
1351 Concrete::PathPoint2D originPathPoint( new Concrete::Coords2D( 0, 0 ) );
1352 Concrete::PathPoint2D * first = & originPathPoint;
1353 Concrete::PathPoint2D * last = & originPathPoint;
1354 const char * srcEnd = buf.getPtr( ) + strlen( buf.getPtr( ) );
1355 for( const char * src = buf.getPtr( ); src < srcEnd; ++src )
1356 {
1357 for( ; *src == ' '; ++src )
1358 ;
1359 if( *src == '\0' )
1360 {
1361 break;
1362 }
1363 switch( *src )
1364 {
1365 case 'M':
1366 case 'm':
1367 case 'Z':
1368 case 'z':
1369 case 'L':
1370 case 'l':
1371 case 'H':
1372 case 'h':
1373 case 'V':
1374 case 'v':
1375 case 'C':
1376 case 'c':
1377 case 'S':
1378 case 's':
1379 {
1380 cmd = *src;
1381 ++src;
1382 break;
1383 }
1384 case 'Q':
1385 case 'q':
1386 case 'T':
1387 case 't':
1388 case 'A':
1389 case 'a':
1390 {
1391 throw Exceptions::CoreOutOfRange( title_, args, 0, strrefdup( std::string( "SVG path command not compatible with cubic splines: " ) + *src ) );
1392 }
1393 }
1394 switch( cmd )
1395 {
1396 case 'M':
1397 {
1398 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1399 {
1400 multiPath->push_back( elemPath );
1401 }
1402 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1403 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1404 first = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1405 last = first;
1406 elemPath = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
1407 elemPath->push_back( last );
1408 cmd = 'L';
1409 break;
1410 }
1411 case 'm':
1412 {
1413 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1414 {
1415 multiPath->push_back( elemPath );
1416 }
1417 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1418 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1419 first = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1420 last = first;
1421 elemPath = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
1422 elemPath->push_back( last );
1423 cmd = 'l';
1424 break;
1425 }
1426 case 'Z':
1427 {
1428 elemPath->close( );
1429 last = first;
1430 break;
1431 }
1432 case 'z':
1433 {
1434 elemPath->close( );
1435 last = first;
1436 break;
1437 }
1438 case 'L':
1439 {
1440 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1441 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1442 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1443 elemPath->push_back( last );
1444 break;
1445 }
1446 case 'l':
1447 {
1448 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1449 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1450 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, y ) );
1451 elemPath->push_back( last );
1452 break;
1453 }
1454 case 'H':
1455 {
1456 Concrete::Length x = dx * Implementation::svg_path_strtod( & src );
1457 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, last->mid_->y_ ) );
1458 elemPath->push_back( last );
1459 break;
1460 }
1461 case 'h':
1462 {
1463 Concrete::Length x = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1464 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x, last->mid_->y_ ) );
1465 elemPath->push_back( last );
1466 break;
1467 }
1468 case 'V':
1469 {
1470 Concrete::Length y = - dy * Implementation::svg_path_strtod( & src );
1471 last = new Concrete::PathPoint2D( new Concrete::Coords2D( last->mid_->x_, y ) );
1472 elemPath->push_back( last );
1473 break;
1474 }
1475 case 'v':
1476 {
1477 Concrete::Length y = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1478 last = new Concrete::PathPoint2D( new Concrete::Coords2D( last->mid_->x_, y ) );
1479 elemPath->push_back( last );
1480 break;
1481 }
1482 case 'C':
1483 {
1484 Concrete::Length x1 = dx * Implementation::svg_path_strtod( & src );
1485 Concrete::Length y1 = - dy * Implementation::svg_path_strtod( & src );
1486 Concrete::Length x2 = dx * Implementation::svg_path_strtod( & src );
1487 Concrete::Length y2 = - dy * Implementation::svg_path_strtod( & src );
1488 Concrete::Length x3 = dx * Implementation::svg_path_strtod( & src );
1489 Concrete::Length y3 = - dy * Implementation::svg_path_strtod( & src );
1490 last->front_ = new Concrete::Coords2D( x1, y1 );
1491 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1492 last->rear_ = new Concrete::Coords2D( x2, y2 );
1493 elemPath->push_back( last );
1494 break;
1495 }
1496 case 'c':
1497 {
1498 Concrete::Length x1 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1499 Concrete::Length y1 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1500 Concrete::Length x2 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1501 Concrete::Length y2 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1502 Concrete::Length x3 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1503 Concrete::Length y3 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1504 last->front_ = new Concrete::Coords2D( x1, y1 );
1505 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1506 last->rear_ = new Concrete::Coords2D( x2, y2 );
1507 elemPath->push_back( last );
1508 break;
1509 }
1510 case 'S':
1511 {
1512 Concrete::Length x2 = dx * Implementation::svg_path_strtod( & src );
1513 Concrete::Length y2 = - dy * Implementation::svg_path_strtod( & src );
1514 Concrete::Length x3 = dx * Implementation::svg_path_strtod( & src );
1515 Concrete::Length y3 = - dy * Implementation::svg_path_strtod( & src );
1516 last->front_ = new Concrete::Coords2D( 2 * *(last->mid_) - *(last->rear_) );
1517 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1518 last->rear_ = new Concrete::Coords2D( x2, y2 );
1519 elemPath->push_back( last );
1520 break;
1521 }
1522 case 's':
1523 {
1524 Concrete::Length x2 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1525 Concrete::Length y2 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1526 Concrete::Length x3 = last->mid_->x_ + dx * Implementation::svg_path_strtod( & src );
1527 Concrete::Length y3 = last->mid_->y_ - dy * Implementation::svg_path_strtod( & src );
1528 last->front_ = new Concrete::Coords2D( 2 * *(last->mid_) - *(last->rear_) );
1529 last = new Concrete::PathPoint2D( new Concrete::Coords2D( x3, y3 ) );
1530 last->rear_ = new Concrete::Coords2D( x2, y2 );
1531 elemPath->push_back( last );
1532 break;
1533 }
1534 case '\0':
1535 throw Exceptions::CoreOutOfRange( title_, args, 0, "Malformed SVG path string (failed to initialize command character)." );
1536 default:
1537 {
1538 throw Exceptions::InternalError( "While reading SVG path string: Command character out of range." );
1539 }
1540 }
1541 }
1542 }
1543 catch( const std::string & badNumber )
1544 {
1545 throw Exceptions::CoreOutOfRange( title_, args, 0, strrefdup( std::string( "Ill-formed number: " ) + badNumber ) );
1546 }
1547
1548 if( elemPath != NullPtr< Lang::ElementaryPath2D >( ) && ( singletons || elemPath->duration( ) >= 1 ) )
1549 {
1550 multiPath->push_back( RefCountPtr< const Lang::Path2D >( elemPath ) );
1551 }
1552
1553 if( multiPath->size( ) == 0 )
1554 {
1555 throw Exceptions::CoreOutOfRange( title_, args, 0, "No path was produced." );
1556 }
1557 if( multiPath->size( ) == 1 )
1558 {
1559 Kernel::ContRef cont = evalState->cont_;
1560 if( multi != NullPtr< FlagType >( ) && multi->val_ )
1561 {
1562 cont->takeValue( Kernel::ValueRef( multiPath ),
1563 evalState );
1564 }
1565 else
1566 {
1567 cont->takeValue( Kernel::ValueRef( multiPath->front( ) ),
1568 evalState );
1569 }
1570 }
1571 else
1572 {
1573 if( multi != NullPtr< FlagType >( ) && ! multi->val_ )
1574 {
1575 throw Exceptions::CoreOutOfRange( title_, args, 0, "More than one sub-path conflicts with false for <multi>." );
1576 }
1577 Kernel::ContRef cont = evalState->cont_;
1578 cont->takeValue( Kernel::ValueRef( multiPath ),
1579 evalState );
1580 }
1581 }
1582 };
1583
1584 class Core_sprintf : public Lang::CoreFunction
1585 {
1586 public:
1587 Core_sprintf( const char * title ) : CoreFunction( title ) { }
1588 virtual void
1589 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1590 {
1591 if( args.empty( ) )
1592 {
1593 throw Exceptions::CoreArityMismatch( title_, 1, args.size( ) );
1594 }
1595 typedef typeof args ArgListType;
1596 size_t i = 0;
1597 typedef const Lang::String Arg1Type;
1598 RefCountPtr< Arg1Type > arg1 = Helpers::down_cast_CoreArgument< Arg1Type >( title_, args, i, callLoc );
1599
1600 /* snprintf( 0, 0, ... ) does not seem to work properly on some systems.
1601 * Therefore, I resort to the use of a dummy string, and "n = 1".
1602 */
1603 char * res = 0;
1604 int status;
1605 char dummy[1];
1606 switch( args.size( ) )
1607 {
1608 case 1:
1609 {
1610 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), 0 ); /* The final 0 is just a dummy argument that makes the compiler relax. */
1611 res = new char[ sz + 1 ];
1612 status = sprintf( res, arg1->val_.getPtr( ), 0 ); /* The final 0 is just a dummy argument that makes the compiler relax. */
1613 }
1614 break;
1615 case 2:
1616 {
1617 ++i;
1618 {
1619 typedef const Lang::String Arg2Type;
1620 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1621 if( arg2 != 0 )
1622 {
1623 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_.getPtr( ) );
1624 res = new char[ sz + 1 ];
1625 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_.getPtr( ) );
1626 break;
1627 }
1628 }
1629 {
1630 typedef const Lang::Float Arg2Type;
1631 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1632 if( arg2 != 0 )
1633 {
1634 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_ );
1635 res = new char[ sz + 1 ];
1636 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_ );
1637 break;
1638 }
1639 }
1640 {
1641 typedef const Lang::Integer Arg2Type;
1642 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1643 if( arg2 != 0 )
1644 {
1645 size_t sz = snprintf( dummy, 1, arg1->val_.getPtr( ), arg2->val_ );
1646 res = new char[ sz + 1 ];
1647 status = sprintf( res, arg1->val_.getPtr( ), arg2->val_ );
1648 break;
1649 }
1650 }
1651 {
1652 typedef const Lang::ChronologicalTime Arg2Type;
1653 Arg2Type * arg2 = dynamic_cast< Arg2Type * >( args.getValue( i ).getPtr( ) );
1654 if( arg2 != 0 )
1655 {
1656 const char * fmt = arg1->val_.getPtr( );
1657 const struct tm * tmp = arg2->temporary_localtime( );
1658 size_t sz = strlen( fmt ) * 2;
1659 res = new char[ sz ];
1660 while( strftime( res, sz, fmt, tmp ) == 0 )
1661 {
1662 delete res;
1663 sz *= 2;
1664 res = new char[ sz ];
1665 }
1666 status = 0; // Here, I'd like to check some error condition instead...
1667 break;
1668 }
1669 }
1670 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, i, Interaction::SEVERAL_TYPES );
1671 }
1672 break;
1673 default:
1674 throw Exceptions::CoreOutOfRange( title_, args, 0, "The number of arguments is out of the implemented range." );
1675 }
1676
1677 if( res == 0 )
1678 {
1679 throw Exceptions::InternalError( "Failed to assign to res in sprintf." );
1680 }
1681
1682 if( status < 0 )
1683 {
1684 std::ostringstream oss;
1685 oss << "Call to library routine returned negative value indicating an error: " << status << ".";
1686 throw Exceptions::CoreOutOfRange( title_, args, 0, strrefdup( oss ) );
1687 }
1688
1689 Kernel::ContRef cont = evalState->cont_;
1690 cont->takeValue( Kernel::ValueRef( new Lang::String( res, false ) ),
1691 evalState );
1692 }
1693 };
1694
1695 class Core_strftime : public Lang::CoreFunction
1696 {
1697 public:
1698 Core_strftime( const char * title ) : CoreFunction( title ) { }
1699 virtual void
1700 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1701 {
1702 const size_t ARITY = 0;
1703 CHECK_ARITY( args, ARITY, title_ );
1704
1705 time_t t;
1706 tm * timeInfo;
1707 t = time( 0 );
1708 timeInfo = localtime( & t );
1709 std::ostringstream res;
1710 res << timeInfo->tm_hour << ":" << timeInfo->tm_min << ":" << timeInfo->tm_sec ;
1711
1712 Kernel::ContRef cont = evalState->cont_;
1713 cont->takeValue( Kernel::ValueRef( new Lang::String( strrefdup( res ) ) ),
1714 evalState );
1715 }
1716 };
1717
1718 class Core_ambient_light : public Lang::CoreFunction
1719 {
1720 public:
1721 Core_ambient_light( const char * title )
1722 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1723 {
1724 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1725 }
1726 virtual void
1727 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1728 {
1729 args.applyDefaults( );
1730
1731 {
1732 typedef const Lang::Gray ArgType;
1733 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1734 if( col != 0 )
1735 {
1736 Kernel::ContRef cont = evalState->cont_;
1737 cont->takeValue( Kernel::ValueRef( new Lang::AmbientLightGray( col->components( ) ) ),
1738 evalState );
1739 return;
1740 }
1741 }
1742
1743 {
1744 typedef const Lang::RGB ArgType;
1745 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1746 if( col != 0 )
1747 {
1748 Kernel::ContRef cont = evalState->cont_;
1749 cont->takeValue( Kernel::ValueRef( new Lang::AmbientLightRGB( col->components( ) ) ),
1750 evalState );
1751 return;
1752 }
1753 }
1754
1755 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1756 }
1757 };
1758
1759 class Core_specular_light : public Lang::CoreFunction
1760 {
1761 public:
1762 Core_specular_light( const char * title )
1763 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1764 {
1765 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1766 formals_->appendEvaluatedCoreFormal( "radius", Helpers::newValHandle( new Lang::Length( HUGE_VAL ) ) );
1767 formals_->appendEvaluatedCoreFormal( "shadows", Kernel::THE_FALSE_VARIABLE );
1768 }
1769 virtual void
1770 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1771 {
1772 args.applyDefaults( );
1773
1774 typedef const Lang::Length RadiusType;
1775 RefCountPtr< RadiusType > radius = Helpers::down_cast_CoreArgument< RadiusType >( title_, args, 1, callLoc );
1776 typedef const Lang::Boolean ShadowsType;
1777 RefCountPtr< ShadowsType > shadows = Helpers::down_cast_CoreArgument< ShadowsType >( title_, args, 2, callLoc );
1778
1779 {
1780 typedef const Lang::Gray ArgType;
1781 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1782 if( col != 0 )
1783 {
1784 Kernel::ContRef cont = evalState->cont_;
1785 cont->takeValue( Kernel::ValueRef( new Lang::SpecularLightGray( Concrete::Coords3D( 0, 0, 0 ),
1786 col->components( ),
1787 radius->get( ),
1788 shadows->val_ ) ),
1789 evalState );
1790 return;
1791 }
1792 }
1793
1794 {
1795 typedef const Lang::RGB ArgType;
1796 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1797 if( col != 0 )
1798 {
1799 Kernel::ContRef cont = evalState->cont_;
1800 cont->takeValue( Kernel::ValueRef( new Lang::SpecularLightRGB( Concrete::Coords3D( 0, 0, 0 ),
1801 col->components( ),
1802 radius->get( ),
1803 shadows->val_ ) ),
1804 evalState );
1805 return;
1806 }
1807 }
1808
1809 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1810 }
1811 };
1812
1813 class Core_distant_light : public Lang::CoreFunction
1814 {
1815 public:
1816 Core_distant_light( const char * title )
1817 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1818 {
1819 formals_->appendEvaluatedCoreFormal( "color", Kernel::THE_SLOT_VARIABLE );
1820 formals_->appendEvaluatedCoreFormal( "shadows", Kernel::THE_FALSE_VARIABLE );
1821 }
1822 virtual void
1823 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1824 {
1825 args.applyDefaults( );
1826
1827 typedef const Lang::Boolean ShadowsType;
1828 RefCountPtr< ShadowsType > shadows = Helpers::down_cast_CoreArgument< ShadowsType >( title_, args, 1, callLoc );
1829
1830 {
1831 typedef const Lang::Gray ArgType;
1832 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1833 if( col != 0 )
1834 {
1835 Kernel::ContRef cont = evalState->cont_;
1836 cont->takeValue( Kernel::ValueRef( new Lang::DistantLightGray( Concrete::UnitFloatTriple( 0., 0., -1. ),
1837 col->components( ),
1838 shadows->val_ ) ),
1839 evalState );
1840 return;
1841 }
1842 }
1843
1844 {
1845 typedef const Lang::RGB ArgType;
1846 ArgType * col = dynamic_cast< ArgType * >( args.getValue( 0 ).getPtr( ) );
1847 if( col != 0 )
1848 {
1849 Kernel::ContRef cont = evalState->cont_;
1850 cont->takeValue( Kernel::ValueRef( new Lang::DistantLightRGB( Concrete::UnitFloatTriple( 0., 0., -1. ),
1851 col->components( ),
1852 shadows->val_ ) ),
1853 evalState );
1854 return;
1855 }
1856 }
1857
1858 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, 0, Helpers::typeSetString( Lang::Gray::staticTypeName( ), Lang::RGB::staticTypeName( ) ) );
1859 }
1860 };
1861
1862 class Core_textrenderingmode : public Lang::CoreFunction
1863 {
1864 public:
1865 Core_textrenderingmode( const char * title )
1866 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
1867 {
1868 formals_->appendEvaluatedCoreFormal( "fill", Kernel::THE_FALSE_VARIABLE );
1869 formals_->appendEvaluatedCoreFormal( "stroke", Kernel::THE_FALSE_VARIABLE );
1870 }
1871 virtual void
1872 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1873 {
1874 args.applyDefaults( );
1875
1876 typedef const Lang::Boolean FlagType;
1877 RefCountPtr< FlagType > fill = Helpers::down_cast_CoreArgument< FlagType >( title_, args, 0, callLoc );
1878 RefCountPtr< FlagType > stroke = Helpers::down_cast_CoreArgument< FlagType >( title_, args, 1, callLoc );
1879
1880 Kernel::ContRef cont = evalState->cont_;
1881 cont->takeValue( Kernel::ValueRef( new Lang::TextRenderingMode( fill->val_, stroke->val_, false ) ),
1882 evalState );
1883 }
1884 };
1885
1886 class Core_manualkern : public Lang::CoreFunction
1887 {
1888 public:
1889 Core_manualkern( const char * title ) : CoreFunction( title ) { }
1890 virtual void
1891 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1892 {
1893 // 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
1894 // the result is not used.
1895 RefCountPtr< Lang::KernedText > res( new Lang::KernedText( evalState->dyn_->getTextState( ), evalState->dyn_->getGraphicsState( ) ) );
1896
1897 for( size_t i = 0; i != args.size( ); ++i )
1898 {
1899 try
1900 {
1901 typedef const Lang::String ArgType;
1902 res->pushString( Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) ) );
1903 continue;
1904 }
1905 catch( const NonLocalExit::NotThisType & ball )
1906 {
1907 // Never mind, see below
1908 }
1909
1910 try
1911 {
1912 typedef const Lang::Float ArgType;
1913 res->pushKerning( Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->val_ );
1914 continue;
1915 }
1916 catch( const NonLocalExit::NotThisType & ball )
1917 {
1918 // Never mind, see below
1919 }
1920
1921 try
1922 {
1923 typedef const Lang::KernedText ArgType;
1924 Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->push( res.getPtr( ) );
1925 continue;
1926 }
1927 catch( const NonLocalExit::NotThisType & ball )
1928 {
1929 // Never mind, see below
1930 }
1931
1932 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, i, Helpers::typeSetString( Lang::String::staticTypeName( ), Lang::Float::staticTypeName( ), Lang::KernedText::staticTypeName( ) ) );
1933 }
1934
1935 Kernel::ContRef cont = evalState->cont_;
1936 cont->takeValue( res,
1937 evalState );
1938 }
1939 };
1940
1941 class Core_automatickern : public Lang::CoreFunction
1942 {
1943 public:
1944 Core_automatickern( const char * title ) : CoreFunction( title ) { }
1945 virtual void
1946 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1947 {
1948 iconv_t converter = Helpers::requireUTF8ToMacRomanConverter( );
1949 iconv_t backconverter = Helpers::requireMacRomanToUTF8Converter( );
1950
1951 RefCountPtr< const FontMetrics::BaseFont > metrics = evalState->dyn_->getTextState( )->font_->metrics( );
1952 if( metrics->horizontalMetrics_ == NullPtr< FontMetrics::WritingDirectionMetrics >( ) )
1953 {
1954 throw Exceptions::FontMetricsError( evalState->dyn_->getTextState( )->font_->fontName( ), strrefdup( "No horizontal metrics defined." ) );
1955 }
1956
1957 // 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
1958 // the result is not used.
1959 RefCountPtr< Lang::KernedText > res( new Lang::KernedText( evalState->dyn_->getTextState( ), evalState->dyn_->getGraphicsState( ) ) );
1960
1961 std::ostringstream pendingChars;
1962 unsigned char prevChar = 0;
1963 double pendingKerning = 0;
1964
1965 size_t backbufSize = 5;
1966 char * backbuf = new char[ backbufSize ];
1967 DeleteOnExit< char > bufDeleter( backbuf );
1968
1969 for( size_t i = 0; i != args.size( ); ++i )
1970 {
1971 try
1972 {
1973 typedef const Lang::String ArgType;
1974 RefCountPtr< ArgType > str = Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) );
1975
1976 const char * inbuf = str->val_.getPtr( );
1977
1978 size_t bufSize = strlen( inbuf ) + 1;
1979 char * buf = new char[ bufSize ];
1980 DeleteOnExit< char > bufDeleter( buf );
1981
1982 char * outbuf = buf;
1983 size_t inbytesleft = bufSize - 1;
1984 size_t outbytesleft = bufSize - 1;
1985 // The ICONV_CAST macro is defined in config.h.
1986 size_t count = iconv( converter,
1987 ICONV_CAST( & inbuf ), & inbytesleft,
1988 & outbuf, & outbytesleft );
1989 if( count == (size_t)(-1) )
1990 {
1991 if( errno == EILSEQ )
1992 {
1993 throw Exceptions::MiscellaneousRequirement( "It is suspected that one of the UFT-8 characters used in showed text has no MacRoman representation." );
1994 }
1995 else if( errno == EINVAL )
1996 {
1997 throw Exceptions::MiscellaneousRequirement( "It is suspected that showed text ended with an incomplete multibyte character." );
1998 }
1999 else if( errno == E2BIG )
2000 {
2001 throw Exceptions::InternalError( "The buffer allocated for UTF-8 to MacRoman conversion was too small." );
2002 }
2003 else
2004 {
2005 std::ostringstream msg;
2006 msg << "iconv failed with an unrecognized error code: " << errno ;
2007 throw Exceptions::InternalError( strrefdup( msg ) );
2008 }
2009 }
2010 *outbuf = '\0';
2011 for( const char * src = buf; *src != '\0'; ++src )
2012 {
2013 unsigned char currentChar = *reinterpret_cast< const unsigned char * >( src );
2014 double currentKerning = pendingKerning - metrics->getHorizontalKernPairXByCode( prevChar, currentChar );
2015 prevChar = currentChar;
2016 pendingKerning = 0;
2017 if( currentKerning != 0 )
2018 {
2019 if( ! pendingChars.str( ).empty( ) )
2020 {
2021 res->pushString( RefCountPtr< const Lang::String >( new Lang::String( strrefdup( pendingChars ) ) ) );
2022 pendingChars.str( "" );
2023 }
2024 res->pushKerning( currentKerning );
2025 }
2026
2027 // Copy the current (multibyte) character to the character queue
2028 {
2029 const char * inbuf = src;
2030 char * outbuf = backbuf;
2031 size_t inbytesleft = 1;
2032 size_t outbytesleft = backbufSize;
2033 // The ICONV_CAST macro is defined in config.h.
2034 size_t count = iconv( backconverter,
2035 ICONV_CAST( & inbuf ), & inbytesleft,
2036 & outbuf, & outbytesleft );
2037 if( count == (size_t)(-1) )
2038 {
2039 if( errno == EILSEQ )
2040 {
2041 throw Exceptions::ExternalError( "A character converted from UTF-8 could not be converted back to UFT-8." );
2042 }
2043 else if( errno == EINVAL )
2044 {
2045 throw Exceptions::ExternalError( "A character converted from UTF-8 was deemed incomplete." );
2046 }
2047 else if( errno == E2BIG )
2048 {
2049 throw Exceptions::InternalError( "The buffer allocated for conversion of a single character back to UTF-8 was too small." );
2050 }
2051 else
2052 {
2053 std::ostringstream msg;
2054 msg << "iconv failed with an unrecognized error code: " << errno ;
2055 throw Exceptions::InternalError( strrefdup( msg ) );
2056 }
2057 }
2058 *outbuf = '\0';
2059 pendingChars << backbuf ;
2060 }
2061 }
2062 continue;
2063 }
2064 catch( const NonLocalExit::NotThisType & ball )
2065 {
2066 // Never mind, see below
2067 }
2068
2069 try
2070 {
2071 typedef const Lang::Float ArgType;
2072 pendingKerning += Helpers::try_cast_CoreArgument< ArgType >( args.getValue( i ) )->val_;
2073 continue;
2074 }
2075 catch( const NonLocalExit::NotThisType & ball )
2076 {
2077 // Never mind, see below
2078 }
2079
2080 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, i, Helpers::typeSetString( Lang::String::staticTypeName( ), Lang::Float::staticTypeName( ) ) );
2081 }
2082
2083 if( ! pendingChars.str( ).empty( ) )
2084 {
2085 res->pushString( RefCountPtr< const Lang::String >( new Lang::String( strrefdup( pendingChars ) ) ) );
2086 pendingChars.str( "" );
2087 }
2088
2089 Kernel::ContRef cont = evalState->cont_;
2090 cont->takeValue( res,
2091 evalState );
2092 }
2093 };
2094
2095 class Core_newrandom : public Lang::CoreFunction
2096 {
2097 public:
2098 Core_newrandom( const char * title )
2099 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
2100 {
2101 formals_->appendEvaluatedCoreFormal( "seed", Kernel::THE_SLOT_VARIABLE );
2102 formals_->appendEvaluatedCoreFormal( "size", Helpers::newValHandle( new Lang::Integer( 32 ) ) );
2103 }
2104 virtual void
2105 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2106 {
2107 args.applyDefaults( );
2108
2109 typedef const Lang::Integer SizeType;
2110 Lang::Integer::ValueType sz = Helpers::down_cast_CoreArgument< SizeType >( title_, args, 1, callLoc )->val_;
2111 if( sz < 8 )
2112 {
2113 throw Exceptions::CoreOutOfRange( title_, args, 1, "The size must be at least 8." );
2114 }
2115 if( sz > 256 )
2116 {
2117 throw Exceptions::CoreOutOfRange( title_, args, 1, "The size must at most 256." );
2118 }
2119
2120 size_t argsi = 0;
2121
2122 try
2123 {
2124 typedef const Lang::ChronologicalTime SeedType;
2125
2126 RefCountPtr< SeedType > seed = Helpers::try_cast_CoreArgument< SeedType >( args.getValue( argsi ) );
2127
2128 Kernel::ContRef cont = evalState->cont_;
2129 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( sz, seed->val( ) ) ),
2130 evalState );
2131 return;
2132 }
2133 catch( const NonLocalExit::NotThisType & ball )
2134 {
2135 // Never mind, see below
2136 }
2137
2138 try
2139 {
2140 typedef const Lang::Integer SeedType;
2141
2142 RefCountPtr< SeedType > seed = Helpers::try_cast_CoreArgument< SeedType >( args.getValue( argsi ) );
2143
2144 Kernel::ContRef cont = evalState->cont_;
2145 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( sz, seed->val_ ) ),
2146 evalState );
2147 return;
2148 }
2149 catch( const NonLocalExit::NotThisType & ball )
2150 {
2151 // Never mind, see below
2152 }
2153
2154 throw Exceptions::CoreTypeMismatch( callLoc, title_, args, argsi, Helpers::typeSetString( Lang::Integer::staticTypeName( ), Lang::ChronologicalTime::staticTypeName( ) ) );
2155 }
2156 };
2157
2158 class Core_devrandom : public Lang::CoreFunction
2159 {
2160 public:
2161 Core_devrandom( const char * title )
2162 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
2163 {
2164 formals_->appendCoreStateFormal( "device" );
2165 formals_->appendEvaluatedCoreFormal( "size", Helpers::newValHandle( new Lang::Integer( 32 ) ) );
2166 }
2167 virtual void
2168 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2169 {
2170 args.applyDefaults( );
2171
2172 typedef const Lang::Integer SizeType;
2173 Lang::Integer::ValueType sz = Helpers::down_cast_CoreArgument< SizeType >( title_, args, 0, callLoc )->val_;
2174 if( sz < 8 )
2175 {
2176 throw Exceptions::CoreOutOfRange( title_, args, 0, "The size must be at least 8." );
2177 }
2178 if( sz > 256 )
2179 {
2180 throw Exceptions::CoreOutOfRange( title_, args, 0, "The size must at most 256." );
2181 }
2182
2183 typedef Kernel::WarmRandomDevice GeneratorType;
2184 GeneratorType * gen = Helpers::down_cast_CoreState< GeneratorType >( title_, args, 0, callLoc );
2185
2186 Kernel::ContRef cont = evalState->cont_;
2187 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::HotRandomSeed( static_cast< size_t >( sz ), gen ) ),
2188 evalState );
2189 }
2190 };
2191
2192 class Core_destination : public Lang::CoreFunction
2193 {
2194 public:
2195 Core_destination( const char * title )
2196 : CoreFunction( title, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( title ), true ) )
2197 {
2198 formals_->appendEvaluatedCoreFormal( "remote", Kernel::THE_FALSE_VARIABLE );
2199 formals_->appendEvaluatedCoreFormal( "name", Kernel::THE_VOID_VARIABLE );
2200 formals_->appendEvaluatedCoreFormal( "level", Kernel::THE_VOID_VARIABLE );
2201 formals_->appendEvaluatedCoreFormal( "text", Kernel::THE_VOID_VARIABLE );
2202 formals_->appendEvaluatedCoreFormal( "open", Kernel::THE_FALSE_VARIABLE );
2203 formals_->appendEvaluatedCoreFormal( "bold", Kernel::THE_FALSE_VARIABLE );
2204 formals_->appendEvaluatedCoreFormal( "italic", Kernel::THE_FALSE_VARIABLE );
2205 formals_->appendEvaluatedCoreFormal( "color", Helpers::newValHandle( new Lang::RGB( Concrete::RGB( 0, 0, 0 ) ) ) );
2206 formals_->appendEvaluatedCoreFormal( "sides", Kernel::THE_VOID_VARIABLE );
2207 formals_->appendEvaluatedCoreFormal( "target", Kernel::THE_VOID_VARIABLE );
2208 formals_->appendEvaluatedCoreFormal( "fittobbox", Kernel::THE_VOID_VARIABLE );
2209 formals_->appendEvaluatedCoreFormal( "zoom", Kernel::THE_VOID_VARIABLE );
2210 formals_->appendEvaluatedCoreFormal( "transform", Kernel::THE_TRUE_VARIABLE );
2211 }
2212 virtual void
2213 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
2214 {
2215 args.applyDefaults( );
2216
2217 size_t argsi = 0;
2218 const size_t remove_i = argsi;
2219 typedef const Lang::Boolean RemoteType;
2220 bool remote = Helpers::down_cast_CoreArgument< RemoteType >( title_, args, argsi, callLoc )->val_;
2221
2222 ++argsi;
2223 typedef const Lang::String NameType;
2224 RefCountPtr< NameType > nameVal = Helpers::down_cast_CoreArgument< NameType >( title_, args, argsi, callLoc, true );
2225 RefCountPtr< const char > name = RefCountPtr< const char >( NullPtr< const char >( ) );
2226 if( nameVal != NullPtr< NameType >( ) )
2227 {
2228 const SimplePDF::PDF_Version::Version STRINGDESTS_VERSION = SimplePDF::PDF_Version::PDF_1_2;
2229 if( Kernel::the_PDF_version.greaterOrEqual( STRINGDESTS_VERSION ) )
2230 {
2231 name = nameVal->val_;
2232 }
2233 else
2234 {
2235 Kernel::the_PDF_version.message( STRINGDESTS_VERSION, "The naming of a destination was ignored." );
2236 // Note that this will leave name being null, and hence generate further errors if remote_.
2237 }
2238 }
2239 if( nameVal == NullPtr< NameType >( ) ) // Note why this is not an else clause!
2240 {
2241 if( remote )
2242 {
2243 throw Exceptions::CoreOutOfRange( title_, args, remove_i, "The destination cannot be remote if no name is given." );
2244 }
2245 }
2246
2247 ++argsi;
2248 const size_t outlineLevel_i = argsi;
2249 typedef const Lang::Integer OutlineLevelType;
2250 RefCountPtr< OutlineLevelType > levelVal = Helpers::down_cast_CoreArgument< OutlineLevelType >( title_, args, argsi, callLoc, true );
2251 int outlineLevel = -1; // This will remain negative only if the level is not present.
2252 if( levelVal != NullPtr< OutlineLevelType >( ) )
2253 {
2254 outlineLevel = levelVal->val_;
2255 if( outlineLevel < 0 )
2256 {
2257 throw Exceptions::CoreOutOfRange( title_, args, argsi, "The outline level must be non-negative." );
2258 }
2259 }
2260
2261 ++argsi;
2262 typedef const Lang::String OutlineTextType;
2263 RefCountPtr< OutlineTextType > textVal = Helpers::down_cast_CoreArgument< OutlineTextType >( title_, args, argsi, callLoc, true );
2264 RefCountPtr< const char > outlineText = RefCountPtr< const char >( NullPtr< const char >( ) );
2265 if( textVal != NullPtr< OutlineTextType >( ) )
2266 {
2267 outlineText = textVal->val_;
2268 }
2269 else
2270 {
2271 if( outlineLevel >= 0 )
2272 {
2273 throw Exceptions::CoreOutOfRange( title_, args, outlineLevel_i, "Without an outline text, it is not allowed to make an outline item." );
2274 }
2275 }
2276
2277 ++argsi;
2278 typedef const Lang::Boolean OutlineOpenType;
2279 bool outlineOpen = Helpers::down_cast_CoreArgument< OutlineOpenType >( title_, args, argsi, callLoc )->val_;
2280
2281 ++argsi;
2282 typedef const Lang::Boolean OutlineBoldType;
2283 bool outlineBold = Helpers::down_cast_CoreArgument< OutlineBoldType >( title_, args, argsi, callLoc )->val_;
2284
2285 ++argsi;
2286 typedef const Lang::Boolean OutlineItalicType;
2287 bool outlineItalic = Helpers::down_cast_CoreArgument< OutlineItalicType >( title_, args, argsi, callLoc )->val_;
2288
2289 ++argsi;
2290 typedef const Lang::RGB OutlineColorType;
2291 Concrete::RGB outlineColor = Helpers::down_cast_CoreArgument< OutlineColorType >( title_, args, argsi, callLoc )->components( );
2292
2293 ++argsi;
2294 const size_t sidesMode_i = argsi;
2295 typedef const Lang::Symbol SidesModeType;
2296 RefCountPtr< SidesModeType > sidesVal = Helpers::down_cast_CoreArgument< SidesModeType >( title_, args, argsi, callLoc, true );
2297
2298 ++argsi;
2299 const size_t target_i = argsi;
2300 typedef const Lang::Drawable2D TargetType;
2301 RefCountPtr< TargetType > target = Helpers::down_cast_CoreArgument< TargetType >( title_, args, argsi, callLoc, true );
2302
2303 Lang::DocumentDestination::Sides sides = Lang::DocumentDestination::PAGE; // Defaults to false, unless a target is given.
2304 if( target != NullPtr< TargetType >( ) )
2305 {
2306 sides = Lang::DocumentDestination::TOPLEFT;
2307 if( remote )
2308 {
2309 throw Exceptions::CoreOutOfRange( title_, args, target_i, "The target can not be specified for remote destinations." );
2310 }
2311 }
2312 static Lang::Symbol SIDES_TopLeft( "topleft" );
2313 static Lang::Symbol SIDES_Page( "page" );
2314 static Lang::Symbol SIDES_Top( "top" );
2315 static Lang::Symbol SIDES_Left( "left" );
2316 static Lang::Symbol SIDES_Rectangle( "rectangle" );
2317 if( sidesVal != NullPtr< SidesModeType >( ) )
2318 {
2319 if( *sidesVal == SIDES_TopLeft )
2320 {
2321 sides = Lang::DocumentDestination::TOPLEFT;
2322 }
2323 else if( *sidesVal == SIDES_Page )
2324 {
2325 if( target != NullPtr< TargetType >( ) )
2326 {
2327 throw Exceptions::CoreOutOfRange( title_, args, sidesMode_i, "The sides mode cannot be page when a target object is present." );
2328 }
2329 sides = Lang::DocumentDestination::PAGE;
2330 }
2331 else if( *sidesVal == SIDES_Top )
2332 {
2333 sides = Lang::DocumentDestination::TOP;
2334 }
2335 else if( *sidesVal == SIDES_Left )
2336 {
2337 sides = Lang::DocumentDestination::LEFT;
2338 }
2339 else if( *sidesVal == SIDES_Rectangle )
2340 {
2341 sides = Lang::DocumentDestination::RECTANGLE;
2342 }
2343 else
2344 {
2345 std::ostringstream oss;
2346 oss << "Valid sides modes are the symbols { "
2347 << SIDES_TopLeft.name( ).getPtr( ) << ", "
2348 << SIDES_Page.name( ).getPtr( ) << ", "
2349 << SIDES_Top.name( ).getPtr( ) << ", "
2350 << SIDES_Left.name( ).getPtr( ) << ", "
2351 << SIDES_Rectangle.name( ).getPtr( )
2352 << " }." ;
2353 throw Exceptions::CoreOutOfRange( title_, args, sidesMode_i, strrefdup( oss ) );
2354 }
2355 }
2356
2357 ++argsi;
2358 typedef const Lang::Boolean FitToType;
2359 RefCountPtr< FitToType > fittobboxVal = Helpers::down_cast_CoreArgument< FitToType >( title_, args, argsi, callLoc, true );
2360 bool fittobbox = false;
2361 if( fittobboxVal != NullPtr< FitToType >( ) )
2362 {
2363 if( remote || sides == Lang::DocumentDestination::TOPLEFT || sides == Lang::DocumentDestination::RECTANGLE )
2364 {
2365 throw Exceptions::CoreOutOfRange( title_, args, argsi, "The fit-to-bbox flag cannot be specified in this mode." );
2366 }
2367 fittobbox = fittobboxVal->val_;
2368 }
2369
2370 ++argsi;
2371 typedef const Lang::Float ZoomType;
2372 RefCountPtr< ZoomType > zoomVal = Helpers::down_cast_CoreArgument< ZoomType >( title_, args, argsi, callLoc, true );
2373 double zoom = 0; // This will remain zero only if the zoom argument is not specified.
2374 if( zoomVal != NullPtr< ZoomType >( ) )
2375 {
2376 if( remote || sides != Lang::DocumentDestination::TOPLEFT )
2377 {
2378 throw Exceptions::CoreOutOfRange( title_, args, argsi, "The zoom can only be specified when using the top-left sides." );
2379 }
2380 zoom = zoomVal->val_;
2381 if( zoom <= 0 )
2382 {
2383 throw Exceptions::CoreOutOfRange( title_, args, argsi, "The zoom value must be positive." );
2384 }
2385 }
2386
2387 ++argsi;
2388 typedef const Lang::Boolean DoTransformType;
2389 bool doTransform = Helpers::down_cast_CoreArgument< DoTransformType >( title_, args, argsi, callLoc )->val_;
2390
2391 Kernel::ContRef cont = evalState->cont_;
2392 if( remote )
2393 {
2394 RefCountPtr< const Lang::DocumentDestination >
2395 taggedObj( new Lang::DocumentDestination( remote, name, outlineLevel,
2396 outlineText, outlineOpen, outlineBold, outlineItalic, outlineColor ) );
2397 cont->takeValue( RefCountPtr< const Lang::Value >
2398 ( new Lang::TaggedValue2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2399 evalState );
2400 }
2401 else
2402 {
2403 RefCountPtr< const Lang::DocumentDestination >
2404 taggedObj( new Lang::DocumentDestination( name, outlineLevel,
2405 outlineText, outlineOpen, outlineBold, outlineItalic, outlineColor,
2406 sides, target, fittobbox, zoom ) );
2407 if( doTransform )
2408 {
2409 cont->takeValue( RefCountPtr< const Lang::Value >
2410 ( new Lang::TaggedGeometric2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2411 evalState );
2412 }
2413 else
2414 {
2415 cont->takeValue( RefCountPtr< const Lang::Value >
2416 ( new Lang::TaggedValue2D( Kernel::THE_NAVIGATION_SYMBOL, taggedObj ) ),
2417 evalState );
2418 }
2419 }
2420 }
2421 };
2422 }
2423 }
2424
2425
2426
2427 void
2428 Kernel::registerCore_construct( Kernel::Environment * env )
2429 {
2430 env->initDefineCoreFunction( new Lang::Core_cons( "cons" ) );
2431 env->initDefineCoreFunction( new Lang::Core_list( "list" ) );
2432 env->initDefineCoreFunction( new Lang::Core_unlist( "unlist" ) );
2433 env->initDefineCoreFunction( new Lang::Core_isnull( "null?" ) );
2434 env->initDefineCoreFunction( new Lang::Core_range( "range" ) );
2435 env->initDefineCoreFunction( new Lang::Core_affinetransform( "affinetransform" ) );
2436 env->initDefineCoreFunction( new Lang::Core_shift( "shift" ) );
2437 env->initDefineCoreFunction( new Lang::Core_rotate( "rotate" ) );
2438 env->initDefineCoreFunction( new Lang::Core_rotate3d( "rotate3D" ) );
2439 env->initDefineCoreFunction( new Lang::Core_scale( "scale" ) );
2440 env->initDefineCoreFunction( new Lang::Core_scale3d( "scale3D" ) );
2441 env->initDefineCoreFunction( new Lang::Core_affinetransform3D( "affinetransform3D" ) );
2442 env->initDefineCoreFunction( new Lang::Core_inverse( "inverse" ) );
2443
2444 env->initDefineCoreFunction( new Lang::Core_formxo( "formxo" ) );
2445 env->initDefineCoreFunction( new Lang::Core_transparencygroup( "tgroup" ) );
2446
2447 env->initDefineCoreFunction( new Lang::Core_tag( "tag" ) );
2448 env->initDefineCoreFunction( new Lang::Core_find( "find" ) );
2449 env->initDefineCoreFunction( new Lang::Core_findall( "findall" ) );
2450
2451 env->initDefineCoreFunction( new Lang::Core_ambient_light( "ambient_light" ) );
2452 env->initDefineCoreFunction( new Lang::Core_specular_light( "specular_light" ) );
2453 env->initDefineCoreFunction( new Lang::Core_distant_light( "distant_light" ) );
2454 env->initDefineCoreFunction( new Lang::Core_phong( "phong" ) );
2455
2456 env->initDefineCoreFunction( new Lang::Core_vector( "vector" ) );
2457 env->initDefineCoreFunction( new Lang::Core_importPDFpages( "import" ) );
2458
2459 env->initDefineCoreFunction( new Lang::Core_svg_path( "svg_path" ) );
2460
2461 env->initDefineCoreFunction( new Lang::Core_sprintf( "sprintf" ) );
2462 env->initDefineCoreFunction( new Lang::Core_strftime( "strftime" ) );
2463
2464 env->initDefineCoreFunction( new Lang::Core_newrandom( "newRandom" ) );
2465 env->initDefineCoreFunction( new Lang::Core_devrandom( "devRandom" ) );
2466
2467 env->initDefineCoreFunction( new Lang::Core_destination( "destination" ) );
2468
2469 env->initDefineCoreFunction( new Lang::Core_textrenderingmode( "textmode" ) );
2470 env->initDefineCoreFunction( new Lang::Core_manualkern( "kerning" ) );
2471 env->initDefineCoreFunction( new Lang::Core_automatickern( "kern" ) );
2472 }
2473
Graphics language