?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update procedures
[shapes.git] / source / hottypes.cc
blob105147a07cd91bc210f4caa94af58d5685dc7e4d
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, 2010, 2013 Henrik Tidefelt
17 */
18
19 #include "Shapes_Helpers_decls.h"
20
21 #include "hottypes.h"
22 #include "globals.h"
23 #include "continuations.h"
24 #include "texttypes.h"
25 #include "fontmetrics.h"
26 #include "tagtypes.h"
27 #include "isnan.h"
28 #include "pdfstructure.h"
29 #include "timetypes.h"
30 #include "shapescore.h"
31 #include "warn.h"
32
33 #include <sstream>
34 #include <limits>
35 #include <sys/resource.h>
36 #include <cstdlib>
37 #include <cstring>
38
39 using namespace Shapes;
40
41
42 Lang::HotTriple::HotTriple( const RefCountPtr< const Lang::Value > & init, RefCountPtr< const Lang::Function > update, RefCountPtr< const Lang::Function > result )
43 : init_( init ), update_( update ), result_( result )
44 { }
45
46 Lang::HotTriple::~HotTriple( )
47 { }
48
49 Kernel::State *
50 Lang::HotTriple::newState( ) const
51 {
52 return new Kernel::WarmTriple( init_, update_, result_ );
53 }
54
55 void
56 Lang::HotTriple::gcMark( Kernel::GCMarkedSet & marked )
57 {
58 const_cast< Lang::Value * >( init_.getPtr( ) )->gcMark( marked );
59 const_cast< Lang::Function * >( update_.getPtr( ) )->gcMark( marked );
60 const_cast< Lang::Function * >( result_.getPtr( ) )->gcMark( marked );
61 }
62
63
64
65 Lang::HotRandomSeed::HotRandomSeed( size_t sz, Kernel::WarmRandomDevice * dev )
66 : sz_( sz ), state_( new char[ sz ] )
67 {
68 char * oldState = initstate( 1, state_, sz_ );
69 dev->read( state_, sz_ );
70 setstate( oldState );
71 }
72
73 Lang::HotRandomSeed::HotRandomSeed( size_t sz, unsigned long seed )
74 : sz_( sz ), state_( new char[ sz ] )
75 {
76 char * oldState = initstate( seed, state_, sz_ );
77 setstate( oldState );
78 }
79
80 Lang::HotRandomSeed::~HotRandomSeed( )
81 {
82 delete state_;
83 }
84
85 Kernel::State *
86 Lang::HotRandomSeed::newState( ) const
87 {
88 char * stateCopy = new char[ sz_ ];
89 memcpy( stateCopy, state_, sz_ );
90 return new Kernel::WarmRandomState( stateCopy ); // This handles ownership to the new state.
91 }
92
93 void
94 Lang::HotRandomSeed::gcMark( Kernel::GCMarkedSet & marked )
95 { }
96
97
98
99
100 Kernel::WarmTriple::WarmTriple( const RefCountPtr< const Lang::Value > & pile, RefCountPtr< const Lang::Function > update, RefCountPtr< const Lang::Function > result )
101 : pile_( pile ), update_( update ), result_( result )
102 { }
103
104 Kernel::WarmTriple::~WarmTriple( )
105 { }
106
107 RefCountPtr< const Lang::Class > Kernel::WarmTriple::TypeID( new Lang::SystemFinalClass( strrefdup( "#UserState" ) ) );
108 TYPEINFOIMPL_STATE( WarmTriple );
109
110 void
111 Kernel::WarmTriple::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
112 {
113 /* This seems dangerous. I have not verified that pile will still exist when the continuation below is invoked.
114 */
115 evalState->cont_ = Kernel::ContRef( new Kernel::StmtStoreValueContinuation( & pile_,
116 evalState->cont_,
117 callLoc ) );
118 update_->call( evalState, pile_, piece, callLoc );
119 }
120
121 void
122 Kernel::WarmTriple::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
123 {
124 /* The right continuation is set by the calling variable.
125 */
126 result_->call( evalState, pile_, callLoc );
127 }
128
129 void
130 Kernel::WarmTriple::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
131 {
132 /* The right continuation is set by the calling variable.
133 */
134 result_->call( evalState, pile_, callLoc );
135 }
136
137 void
138 Kernel::WarmTriple::gcMark( Kernel::GCMarkedSet & marked )
139 {
140 const_cast< Lang::Value * >( pile_.getPtr( ) )->gcMark( marked );
141 const_cast< Lang::Function * >( update_.getPtr( ) )->gcMark( marked );
142 const_cast< Lang::Function * >( result_.getPtr( ) )->gcMark( marked );
143 }
144
145
146 Kernel::WarmIgnore::WarmIgnore( )
147 { }
148
149 Kernel::WarmIgnore::~WarmIgnore( )
150 { }
151
152 RefCountPtr< const Lang::Class > Kernel::WarmIgnore::TypeID( new Lang::SystemFinalClass( strrefdup( "#Ignore" ) ) );
153 TYPEINFOIMPL_STATE( WarmIgnore );
154
155 void
156 Kernel::WarmIgnore::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
157 {
158 /* Ignore piece! */
159
160 Kernel::ContRef cont = evalState->cont_;
161 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
162 evalState );
163 }
164
165 void
166 Kernel::WarmIgnore::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
167 {
168 throw Exceptions::MiscellaneousRequirement( strrefdup( "An ignore state cannot be frozen." ) );
169 }
170
171 void
172 Kernel::WarmIgnore::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
173 {
174 throw Exceptions::MiscellaneousRequirement( strrefdup( "An ignore state cannot be peeked." ) );
175 }
176
177 void
178 Kernel::WarmIgnore::gcMark( Kernel::GCMarkedSet & marked )
179 { }
180
181
182 Kernel::WarmOstream::WarmOstream( std::ostream & os )
183 : os_( os )
184 { }
185
186 Kernel::WarmOstream::~WarmOstream( )
187 { }
188
189 RefCountPtr< const Lang::Class > Kernel::WarmOstream::TypeID( new Lang::SystemFinalClass( strrefdup( "#OutputStream" ) ) );
190 TYPEINFOIMPL_STATE( WarmOstream );
191
192 void
193 Kernel::WarmOstream::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
194 {
195 piece->show( os_ );
196 Kernel::ContRef cont = evalState->cont_;
197 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
198 evalState );
199 }
200
201 void
202 Kernel::WarmOstream::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
203 {
204 throw Exceptions::MiscellaneousRequirement( strrefdup( "A warm ostream cannot be frozen." ) );
205 }
206
207 void
208 Kernel::WarmOstream::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
209 {
210 throw Exceptions::MiscellaneousRequirement( strrefdup( "A warm ostream cannot be peeked." ) );
211 }
212
213 void
214 Kernel::WarmOstream::gcMark( Kernel::GCMarkedSet & marked )
215 { }
216
217
218 Kernel::Warm_ostringstream::Warm_ostringstream( )
219 { }
220
221 Kernel::Warm_ostringstream::~Warm_ostringstream( )
222 { }
223
224 RefCountPtr< const Lang::Class > Kernel::Warm_ostringstream::TypeID( new Lang::SystemFinalClass( strrefdup( "#StringConcatenator" ) ) );
225 TYPEINFOIMPL_STATE( Warm_ostringstream );
226
227 void
228 Kernel::Warm_ostringstream::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
229 {
230 piece->show( os_ );
231 Kernel::ContRef cont = evalState->cont_;
232 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
233 evalState );
234 }
235
236 void
237 Kernel::Warm_ostringstream::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
238 {
239 Kernel::ContRef cont = evalState->cont_;
240 cont->takeValue( Kernel::ValueRef( new Lang::String( strrefdup( os_.str( ).c_str( ) ) ) ),
241 evalState );
242 }
243
244 void
245 Kernel::Warm_ostringstream::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
246 {
247 Kernel::ContRef cont = evalState->cont_;
248 cont->takeValue( Kernel::ValueRef( new Lang::String( strrefdup( os_.str( ).c_str( ) ) ) ),
249 evalState );
250 }
251
252 void
253 Kernel::Warm_ostringstream::gcMark( Kernel::GCMarkedSet & marked )
254 { }
255
256 namespace Shapes
257 {
258 namespace Kernel
259 {
260
261 template< class T >
262 class Mutator_erase : public Lang::CoreMutator
263 {
264 public:
265 Mutator_erase( const char * name )
266 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
267 {
268 }
269 virtual void
270 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
271 {
272 args.applyDefaults( callLoc );
273
274 typedef T StateType;
275 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
276 state->erase( );
277
278 Kernel::ContRef cont = evalState->cont_;
279 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
280 evalState );
281 }
282 };
283
284 template< class T >
285 class Mutator_remove : public Lang::CoreMutator
286 {
287 public:
288 Mutator_remove( const char * name )
289 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
290 {
291 formals_->appendEvaluatedCoreFormal( "key", Kernel::THE_SLOT_VARIABLE );
292 }
293 virtual void
294 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
295 {
296 args.applyDefaults( callLoc );
297
298 typedef T StateType;
299 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
300
301 typedef const Lang::Symbol KeyType;
302 RefCountPtr< KeyType > key = Helpers::down_cast_MutatorArgument< KeyType >( state, name_, args, 0, callLoc );
303
304 state->remove( key->getKey( ) );
305
306 Kernel::ContRef cont = evalState->cont_;
307 cont->takeValue( Lang::THE_VOID,
308 evalState );
309 }
310 };
311
312 }
313 }
314
315
316 Kernel::WarmGroup2D::WarmGroup2D( )
317 : pile_( Lang::THE_NULL2D )
318 { }
319
320 Kernel::WarmGroup2D::~WarmGroup2D( )
321 { }
322
323 void
324 WarmGroup2D_register_mutators( Lang::SystemFinalClass * dstClass )
325 {
326 dstClass->registerMutator( new Kernel::Mutator_erase< Kernel::WarmGroup2D >( "erase" ) );
327 dstClass->registerMutator( new Kernel::Mutator_remove< Kernel::WarmGroup2D >( "remove" ) );
328 }
329
330 RefCountPtr< const Lang::Class > Kernel::WarmGroup2D::TypeID( new Lang::SystemFinalClass( strrefdup( "#Group2D" ), WarmGroup2D_register_mutators ) );
331 TYPEINFOIMPL_STATE( WarmGroup2D );
332
333
334 void
335 Kernel::WarmGroup2D::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
336 {
337 typedef const Lang::Drawable2D ArgType;
338 RefCountPtr< ArgType > arg = Helpers::down_cast< ArgType >( piece, callLoc );
339
340 {
341 /* For objects of user-defined type, we also check that the class inherits from Drawable.
342 */
343 typedef const Lang::Instance UserType;
344 UserType * obj = dynamic_cast< UserType * >( arg.getPtr( ) );
345 if( obj != 0 )
346 {
347 if( ! obj->getClass( )->method_isa( Lang::Drawable2D::TypeID ) )
348 {
349 throw Exceptions::TypeMismatch( callLoc, "2D insertion", piece->getTypeName( ), ArgType::staticTypeName( ) );
350 }
351 }
352 }
353
354 pile_ = RefCountPtr< const Lang::Group2D >( new Lang::GroupPair2D( arg,
355 pile_,
356 evalState->dyn_->getGraphicsState( ) ) );
357 Kernel::ContRef cont = evalState->cont_;
358 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
359 evalState );
360 }
361
362 void
363 Kernel::WarmGroup2D::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
364 {
365 Kernel::ContRef cont = evalState->cont_;
366 cont->takeValue( pile_,
367 evalState );
368 }
369
370 void
371 Kernel::WarmGroup2D::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
372 {
373 Kernel::ContRef cont = evalState->cont_;
374 cont->takeValue( pile_,
375 evalState );
376 }
377
378 void
379 Kernel::WarmGroup2D::erase( )
380 {
381 pile_ = Lang::THE_NULL2D;
382 }
383
384 void
385 Kernel::WarmGroup2D::remove( Lang::Symbol::KeyType key )
386 {
387 pile_ = pile_->removeShallow( key );
388 }
389
390 void
391 Kernel::WarmGroup2D::gcMark( Kernel::GCMarkedSet & marked )
392 {
393 const_cast< Lang::Group2D * >( pile_.getPtr( ) )->gcMark( marked );
394 }
395
396
397
398 Kernel::WarmGroup3D::WarmGroup3D( )
399 : pile_( Lang::THE_NULL3D )
400 { }
401
402 Kernel::WarmGroup3D::~WarmGroup3D( )
403 { }
404
405 void
406 WarmGroup3D_register_mutators( Lang::SystemFinalClass * dstClass )
407 {
408 dstClass->registerMutator( new Kernel::Mutator_erase< Kernel::WarmGroup3D >( "erase" ) );
409 dstClass->registerMutator( new Kernel::Mutator_remove< Kernel::WarmGroup3D >( "remove" ) );
410 }
411
412 RefCountPtr< const Lang::Class > Kernel::WarmGroup3D::TypeID( new Lang::SystemFinalClass( strrefdup( "#Group3D" ), WarmGroup3D_register_mutators ) );
413 TYPEINFOIMPL_STATE( WarmGroup3D );
414
415 void
416 Kernel::WarmGroup3D::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
417 {
418 pile_ = RefCountPtr< const Lang::Group3D >( new Lang::GroupPair3D( Helpers::down_cast< const Lang::Drawable3D >( piece, callLoc ),
419 pile_,
420 evalState->dyn_->getGraphicsState( ) ) );
421 Kernel::ContRef cont = evalState->cont_;
422 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
423 evalState );
424 }
425
426 void
427 Kernel::WarmGroup3D::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
428 {
429 Kernel::ContRef cont = evalState->cont_;
430 cont->takeValue( pile_,
431 evalState );
432 }
433
434 void
435 Kernel::WarmGroup3D::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
436 {
437 Kernel::ContRef cont = evalState->cont_;
438 cont->takeValue( pile_,
439 evalState );
440 }
441
442 void
443 Kernel::WarmGroup3D::erase( )
444 {
445 pile_ = Lang::THE_NULL3D;
446 }
447
448 void
449 Kernel::WarmGroup3D::remove( Lang::Symbol::KeyType key )
450 {
451 pile_ = pile_->removeShallow( key );
452 }
453
454 void
455 Kernel::WarmGroup3D::gcMark( Kernel::GCMarkedSet & marked )
456 {
457 const_cast< Lang::Group3D * >( pile_.getPtr( ) )->gcMark( marked );
458 }
459
460
461 Kernel::WarmGroupLights::WarmGroupLights( )
462 : pile_( Lang::THE_NULL_LIGHTS )
463 { }
464
465 Kernel::WarmGroupLights::~WarmGroupLights( )
466 { }
467
468 RefCountPtr< const Lang::Class > Kernel::WarmGroupLights::TypeID( new Lang::SystemFinalClass( strrefdup( "#GroupLights" ) ) );
469 TYPEINFOIMPL_STATE( WarmGroupLights );
470
471 void
472 Kernel::WarmGroupLights::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
473 {
474 pile_ = RefCountPtr< const Lang::LightGroup >( new Lang::LightPair( Helpers::down_cast< const Lang::LightSource >( piece, callLoc ),
475 pile_ ) );
476 Kernel::ContRef cont = evalState->cont_;
477 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
478 evalState );
479 }
480
481 void
482 Kernel::WarmGroupLights::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
483 {
484 Kernel::ContRef cont = evalState->cont_;
485 cont->takeValue( pile_,
486 evalState );
487 }
488
489 void
490 Kernel::WarmGroupLights::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
491 {
492 Kernel::ContRef cont = evalState->cont_;
493 cont->takeValue( pile_,
494 evalState );
495 }
496
497 void
498 Kernel::WarmGroupLights::gcMark( Kernel::GCMarkedSet & marked )
499 {
500 const_cast< Lang::LightGroup * >( pile_.getPtr( ) )->gcMark( marked );
501 }
502
503
504 Kernel::WarmZBuf::WarmZBuf( )
505 { }
506
507 Kernel::WarmZBuf::~WarmZBuf( )
508 { }
509
510 RefCountPtr< const Lang::Class > Kernel::WarmZBuf::TypeID( new Lang::SystemFinalClass( strrefdup( "#ZBuf" ) ) );
511 TYPEINFOIMPL_STATE( WarmZBuf );
512
513 void
514 Kernel::WarmZBuf::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
515 {
516 try
517 {
518 typedef const Lang::Drawable3D ArgType;
519 RefCountPtr< ArgType > drawable = Helpers::try_cast_CoreArgument< ArgType >( piece );
520 try
521 {
522 drawable->polygonize( pile_.getPtr( ), strokePile_.getPtr( ), evalState->dyn_, Lang::THE_3D_IDENTITY, drawable );
523 }
524 catch( const char * ball )
525 {
526 std::ostringstream oss;
527 oss << "Conversion to polygon failed with: " << ball ;
528 throw Exceptions::OutOfRange( callLoc, strrefdup( oss ) );
529 }
530 Kernel::ContRef cont = evalState->cont_;
531 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
532 evalState );
533 return;
534 }
535 catch( const NonLocalExit::NotThisType & ball )
536 {
537 /* Wrong type; never mind!.. but see below!
538 */
539 }
540
541 try
542 {
543 lightPile_->push_back( Helpers::try_cast_CoreArgument< const Lang::LightSource >( piece ) );
544 Kernel::ContRef cont = evalState->cont_;
545 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
546 evalState );
547 return;
548 }
549 catch( const NonLocalExit::NotThisType & ball )
550 {
551 /* Wrong type; never mind!.. but see below!
552 */
553 }
554
555 try
556 {
557 typedef const Lang::LightGroup ArgType;
558 RefCountPtr< ArgType > lights = Helpers::try_cast_CoreArgument< ArgType >( piece );
559
560 while( ! lights->isNull( ) )
561 {
562 typedef const Lang::LightPair PairType;
563 RefCountPtr< PairType > p = lights.down_cast< PairType >( );
564 lightPile_->push_back( p->car( ) );
565 lights = p->cdr( );
566 }
567
568 Kernel::ContRef cont = evalState->cont_;
569 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
570 evalState );
571 return;
572 }
573 catch( const NonLocalExit::NotThisType & ball )
574 {
575 /* Wrong type; never mind!.. but see below!
576 */
577 }
578
579 throw Exceptions::TypeMismatch( callLoc, piece->getTypeName( ), Helpers::typeSetString( Lang::Drawable3D::staticTypeName( ), Lang::LightSource::staticTypeName( ) ) );
580 }
581
582 void
583 Kernel::WarmZBuf::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
584 {
585 Kernel::ContRef cont = evalState->cont_;
586 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::ZBuf( pile_, strokePile_, lightPile_, evalState->dyn_->getGraphicsState( ) ) ),
587 evalState );
588 }
589
590 void
591 Kernel::WarmZBuf::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
592 {
593 throw Exceptions::MiscellaneousRequirement( strrefdup( "A z-buffer state cannot be peeked." ) );
594 }
595
596 void
597 Kernel::WarmZBuf::gcMark( Kernel::GCMarkedSet & marked )
598 {
599 {
600 typedef typeof *pile_ ListType;
601 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
602 {
603 const_cast< Computation::PaintedPolygon3D * >( i->getPtr( ) )->gcMark( marked );
604 }
605 }
606 // {
607 // typedef typeof *strokePile_ ListType;
608 // for( ListType::const_iterator i = strokePile_->begin( ); i != strokePile_->end( ); ++i )
609 // {
610 // const_cast< Computation::StrokedLine3D * >( i->getPtr( ) )->gcMark( marked );
611 // }
612 // }
613 {
614 typedef typeof *lightPile_ ListType;
615 for( ListType::const_iterator i = lightPile_->begin( ); i != lightPile_->end( ); ++i )
616 {
617 const_cast< Lang::LightSource * >( i->getPtr( ) )->gcMark( marked );
618 }
619 }
620 }
621
622
623 Kernel::WarmZSorter::WarmZSorter( )
624 { }
625
626 Kernel::WarmZSorter::~WarmZSorter( )
627 { }
628
629 RefCountPtr< const Lang::Class > Kernel::WarmZSorter::TypeID( new Lang::SystemFinalClass( strrefdup( "#ZSorter" ) ) );
630 TYPEINFOIMPL_STATE( WarmZSorter );
631
632 void
633 Kernel::WarmZSorter::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
634 {
635 try
636 {
637 typedef const Lang::Drawable3D ArgType;
638 RefCountPtr< ArgType > drawable = Helpers::try_cast_CoreArgument< ArgType >( piece );
639 try
640 {
641 drawable->polygonize( pile_.getPtr( ), strokePile_.getPtr( ), evalState->dyn_, Lang::THE_3D_IDENTITY, drawable );
642 }
643 catch( const char * ball )
644 {
645 std::ostringstream oss;
646 oss << "Conversion to polygon failed with: " << ball ;
647 throw Exceptions::OutOfRange( callLoc, strrefdup( oss ) );
648 }
649 Kernel::ContRef cont = evalState->cont_;
650 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
651 evalState );
652 return;
653 }
654 catch( const NonLocalExit::NotThisType & ball )
655 {
656 /* Wrong type; never mind!.. but see below!
657 */
658 }
659
660 try
661 {
662 lightPile_->push_back( Helpers::try_cast_CoreArgument< const Lang::LightSource >( piece ) );
663 Kernel::ContRef cont = evalState->cont_;
664 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
665 evalState );
666 return;
667 }
668 catch( const NonLocalExit::NotThisType & ball )
669 {
670 /* Wrong type; never mind!.. but see below!
671 */
672 }
673
674 try
675 {
676 typedef const Lang::LightGroup ArgType;
677 RefCountPtr< ArgType > lights = Helpers::try_cast_CoreArgument< ArgType >( piece );
678
679 while( ! lights->isNull( ) )
680 {
681 typedef const Lang::LightPair PairType;
682 RefCountPtr< PairType > p = lights.down_cast< PairType >( );
683 lightPile_->push_back( p->car( ) );
684 lights = p->cdr( );
685 }
686
687 Kernel::ContRef cont = evalState->cont_;
688 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
689 evalState );
690 return;
691 }
692 catch( const NonLocalExit::NotThisType & ball )
693 {
694 /* Wrong type; never mind!.. but see below!
695 */
696 }
697
698 throw Exceptions::TypeMismatch( callLoc, piece->getTypeName( ), Helpers::typeSetString( Lang::Drawable3D::staticTypeName( ), Lang::LightSource::staticTypeName( ) ) );
699 }
700
701 void
702 Kernel::WarmZSorter::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
703 {
704 Kernel::ContRef cont = evalState->cont_;
705 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::ZSorter( pile_, strokePile_, lightPile_, evalState->dyn_->getGraphicsState( ) ) ),
706 evalState );
707 }
708
709 void
710 Kernel::WarmZSorter::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
711 {
712 throw Exceptions::MiscellaneousRequirement( strrefdup( "A z-sorter state cannot be peeked." ) );
713 }
714
715 void
716 Kernel::WarmZSorter::gcMark( Kernel::GCMarkedSet & marked )
717 {
718 {
719 typedef typeof *pile_ ListType;
720 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
721 {
722 const_cast< Computation::PaintedPolygon3D * >( i->getPtr( ) )->gcMark( marked );
723 }
724 }
725 // {
726 // typedef typeof *strokePile_ ListType;
727 // for( ListType::const_iterator i = strokePile_->begin( ); i != strokePile_->end( ); ++i )
728 // {
729 // const_cast< Computation::StrokedLine3D * >( i->getPtr( ) )->gcMark( marked );
730 // }
731 // }
732 {
733 typedef typeof *lightPile_ ListType;
734 for( ListType::const_iterator i = lightPile_->begin( ); i != lightPile_->end( ); ++i )
735 {
736 const_cast< Lang::LightSource * >( i->getPtr( ) )->gcMark( marked );
737 }
738 }
739 }
740
741
742 Kernel::WarmTimer::WarmTimer( )
743 {
744 rusage ru;
745 int res = getrusage( RUSAGE_SELF, &ru );
746 if( res != 0 )
747 {
748 throw Exceptions::InternalError( strrefdup( "getrusage failed." ) );
749 }
750 start_ = ru.ru_utime;
751 }
752
753 Kernel::WarmTimer::~WarmTimer( )
754 { }
755
756 RefCountPtr< const Lang::Class > Kernel::WarmTimer::TypeID( new Lang::SystemFinalClass( strrefdup( "#Timer" ) ) );
757 TYPEINFOIMPL_STATE( WarmTimer );
758
759 void
760 Kernel::WarmTimer::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
761 {
762 throw Exceptions::MiscellaneousRequirement( strrefdup( "A warm timer does not accept values. Please freeze to obtain the number of seconds since creation." ) );
763 }
764
765 void
766 Kernel::WarmTimer::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
767 {
768 rusage ru;
769 int res = getrusage( RUSAGE_SELF, &ru );
770 if( res != 0 )
771 {
772 throw Exceptions::InternalError( strrefdup( "getrusage failed." ) );
773 }
774 timeval stop = ru.ru_utime;
775 double time1 = start_.tv_usec / 1000000.0 + start_.tv_sec;
776 double time2 = stop.tv_usec / 1000000.0 + stop.tv_sec;
777
778 Kernel::ContRef cont = evalState->cont_;
779 cont->takeValue( Kernel::ValueRef( new Lang::Float( time2 - time1 ) ),
780 evalState );
781 }
782
783 void
784 Kernel::WarmTimer::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
785 {
786 rusage ru;
787 int res = getrusage( RUSAGE_SELF, &ru );
788 if( res != 0 )
789 {
790 throw Exceptions::InternalError( strrefdup( "grtrusage failed." ) );
791 }
792 timeval stop = ru.ru_utime;
793 double time1 = start_.tv_usec / 1000000.0 + start_.tv_sec;
794 double time2 = stop.tv_usec / 1000000.0 + stop.tv_sec;
795
796 Kernel::ContRef cont = evalState->cont_;
797 cont->takeValue( Kernel::ValueRef( new Lang::Float( time2 - time1 ) ),
798 evalState );
799 }
800
801 void
802 Kernel::WarmTimer::gcMark( Kernel::GCMarkedSet & marked )
803 { }
804
805
806 Kernel::WarmText::WarmText( )
807 { }
808
809 Kernel::WarmText::~WarmText( )
810 { }
811
812 RefCountPtr< const Lang::Class > Kernel::WarmText::TypeID( new Lang::SystemFinalClass( strrefdup( "#Text" ) ) );
813 TYPEINFOIMPL_STATE( WarmText );
814
815 void
816 Kernel::WarmText::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
817 {
818 try
819 {
820 typedef const Lang::TextOperation ArgType;
821 pile_->push_back( Helpers::try_cast_CoreArgument< ArgType >( piece ) );
822 Kernel::ContRef cont = evalState->cont_;
823 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
824 evalState );
825 return;
826 }
827 catch( const NonLocalExit::NotThisType & ball )
828 {
829 /* Wrong type; never mind!.. but see below!
830 */
831 }
832
833 try
834 {
835 typedef const Lang::String ArgType;
836 RefCountPtr< ArgType > str = Helpers::try_cast_CoreArgument< ArgType >( piece );
837 Lang::KernedText * text = new Lang::KernedText( evalState->dyn_->getTextState( ), evalState->dyn_->getGraphicsState( ) );
838 text->pushString( str );
839 pile_->push_back( RefCountPtr< const Lang::TextOperation >( text ) );
840 Kernel::ContRef cont = evalState->cont_;
841 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
842 evalState );
843 return;
844 }
845 catch( const NonLocalExit::NotThisType & ball )
846 {
847 /* Wrong type; never mind!.. but see below!
848 */
849 }
850
851 try
852 {
853 typedef const Lang::Transform2D ArgType;
854 RefCountPtr< ArgType > tf = Helpers::try_cast_CoreArgument< ArgType >( piece );
855 pile_->push_back( RefCountPtr< const Lang::TextOperation >( new Lang::TextMoveto( tf ) ) );
856 Kernel::ContRef cont = evalState->cont_;
857 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
858 evalState );
859 return;
860 }
861 catch( const NonLocalExit::NotThisType & ball )
862 {
863 /* Wrong type; never mind!.. but see below!
864 */
865 }
866
867 try
868 {
869 typedef const Lang::Coords2D ArgType;
870 RefCountPtr< ArgType > t = Helpers::try_cast_CoreArgument< ArgType >( piece );
871 pile_->push_back( RefCountPtr< const Lang::TextOperation >( new Lang::TextNewline( t->x_.get( ), t->y_.get( ) ) ) );
872 Kernel::ContRef cont = evalState->cont_;
873 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
874 evalState );
875 return;
876 }
877 catch( const NonLocalExit::NotThisType & ball )
878 {
879 /* Wrong type; never mind!.. but see below!
880 */
881 }
882
883 try
884 {
885 typedef const Lang::FloatPair ArgType;
886 RefCountPtr< ArgType > t = Helpers::try_cast_CoreArgument< ArgType >( piece );
887 Concrete::Length sz = evalState->dyn_->getTextState( )->size_;
888 pile_->push_back( RefCountPtr< const Lang::TextOperation >( new Lang::TextNewline( sz * t->x_, sz * t->y_ ) ) );
889 Kernel::ContRef cont = evalState->cont_;
890 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
891 evalState );
892 return;
893 }
894 catch( const NonLocalExit::NotThisType & ball )
895 {
896 /* Wrong type; never mind!.. but see below!
897 */
898 }
899
900 throw Exceptions::TypeMismatch( callLoc, piece->getTypeName( ), Helpers::typeSetString( Lang::TextOperation::staticTypeName( ), Lang::String::staticTypeName( ) ) );
901 }
902
903 void
904 Kernel::WarmText::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
905 {
906 if( pile_->empty( ) )
907 {
908 Kernel::ContRef cont = evalState->cont_;
909 cont->takeValue( Lang::THE_NULL2D,
910 evalState );
911 return;
912 }
913
914 Concrete::Length xmin = Concrete::HUGE_LENGTH;
915 Concrete::Length xmax = -Concrete::HUGE_LENGTH;
916 Concrete::Length ymin = Concrete::HUGE_LENGTH;
917 Concrete::Length ymax = -Concrete::HUGE_LENGTH;
918
919 {
920 Lang::Transform2D textMatrix( 1, 0, 0, 1, 0, 0 );
921 Lang::Transform2D textLineMatrix( 1, 0, 0, 1, 0, 0 );
922 typedef typeof *pile_ ListType;
923 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
924 {
925 (*i)->measure( & textMatrix, & textLineMatrix, & xmin, & ymin, & xmax, & ymax );
926 }
927 }
928
929 Lang::ElementaryPath2D * bbox = new Lang::ElementaryPath2D;
930
931 if( xmin < Concrete::HUGE_LENGTH )
932 {
933 bbox->push_back( new Concrete::PathPoint2D( xmin, ymin ) );
934 bbox->push_back( new Concrete::PathPoint2D( xmin, ymax ) );
935 bbox->push_back( new Concrete::PathPoint2D( xmax, ymax ) );
936 bbox->push_back( new Concrete::PathPoint2D( xmax, ymin ) );
937 bbox->close( );
938 }
939
940 Kernel::ContRef cont = evalState->cont_;
941 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::Text( evalState->dyn_->getTextState( ),
942 pile_,
943 RefCountPtr< const Lang::ElementaryPath2D >( bbox ) ) ),
944 evalState );
945 }
946
947 void
948 Kernel::WarmText::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
949 {
950 throw Exceptions::MiscellaneousRequirement( strrefdup( "A text graphics state cannot be peeked." ) );
951 }
952
953 void
954 Kernel::WarmText::gcMark( Kernel::GCMarkedSet & marked )
955 {
956 typedef typeof *pile_ ListType;
957 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
958 {
959 const_cast< Lang::TextOperation * >( i->getPtr( ) )->gcMark( marked );
960 }
961 }
962
963
964 Kernel::WarmType3Font::WarmType3Font( )
965 : metrics_( new FontMetrics::AFM( ) ), size_( -1 )
966 {
967 metrics_->capHeight_ = std::numeric_limits< double >::signaling_NaN( );
968 metrics_->xHeight_ = std::numeric_limits< double >::signaling_NaN( );
969 metrics_->ascender_ = std::numeric_limits< double >::signaling_NaN( );
970 metrics_->descender_ = std::numeric_limits< double >::signaling_NaN( );
971 metrics_->leading_ = std::numeric_limits< double >::signaling_NaN( );
972 metrics_->stdHW_ = std::numeric_limits< double >::signaling_NaN( );
973 metrics_->stdVW_ = std::numeric_limits< double >::signaling_NaN( );
974 metrics_->fontBBoxXMin_ = 0;
975 metrics_->fontBBoxXMax_ = -1;
976
977 horizontalMetrics_typed_ = new FontMetrics::SingleByte_WritingDirectionMetrics( );
978 metrics_->horizontalMetrics_ = RefCountPtr< FontMetrics::WritingDirectionMetrics >( horizontalMetrics_typed_ );
979 horizontalMetrics_typed_->underlinePosition_ = std::numeric_limits< double >::signaling_NaN( );
980 horizontalMetrics_typed_->underlineThickness_ = std::numeric_limits< double >::signaling_NaN( );
981 horizontalMetrics_typed_->italicAngleRadians_ = std::numeric_limits< double >::signaling_NaN( );
982 }
983
984 Kernel::WarmType3Font::~WarmType3Font( )
985 { }
986
987 RefCountPtr< const Lang::Class > Kernel::WarmType3Font::TypeID( new Lang::SystemFinalClass( strrefdup( "#Type3Font" ) ) );
988 TYPEINFOIMPL_STATE( WarmType3Font );
989
990 void
991 Kernel::WarmType3Font::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
992 {
993 try
994 {
995 typedef const Lang::Type3Glyph ArgType;
996 glyphs_.push_back( Helpers::try_cast_CoreArgument< ArgType >( piece ) );
997 Kernel::ContRef cont = evalState->cont_;
998 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
999 evalState );
1000 return;
1001 }
1002 catch( const NonLocalExit::NotThisType & ball )
1003 {
1004 /* Wrong type; never mind!.. but see below!
1005 */
1006 }
1007
1008 try
1009 {
1010 typedef const Lang::KernedText ArgType;
1011 kernings_.push_back( Helpers::try_cast_CoreArgument< ArgType >( piece ) );
1012 Kernel::ContRef cont = evalState->cont_;
1013 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
1014 evalState );
1015 return;
1016 }
1017 catch( const NonLocalExit::NotThisType & ball )
1018 {
1019 /* Wrong type; never mind!.. but see below!
1020 */
1021 }
1022
1023 try
1024 {
1025 typedef const Lang::TaggedValue2D ArgType;
1026 RefCountPtr< ArgType > taggedVal = Helpers::try_cast_CoreArgument< ArgType >( piece );
1027
1028 RefCountPtr< const char > tagMem = Lang::Symbol::nameFromKey( taggedVal->key( ) );
1029 const char * tag = tagMem.getPtr( );
1030 RefCountPtr< const Lang::Value > val = taggedVal->val( );
1031
1032 if( strcmp( tag, "size" ) == 0 )
1033 {
1034 if( size_ > 0 )
1035 {
1036 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1037 }
1038 typedef const Lang::Length ValType;
1039 size_ = Helpers::down_cast< ValType >( val, callLoc )->get( );
1040 if( ! ( size_ > 0 ) )
1041 {
1042 throw Exceptions::OutOfRange( callLoc, "The size must be positive." );
1043 }
1044 }
1045 else if( strcmp( tag, "FontName" ) == 0 )
1046 {
1047 if( metrics_->fontName_ != NullPtr< const char >( ) )
1048 {
1049 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1050 }
1051 typedef const Lang::Symbol ValType;
1052 metrics_->fontName_ = Helpers::down_cast< ValType >( val, callLoc )->name( );
1053 }
1054 else if( strcmp( tag, "FullName" ) == 0 )
1055 {
1056 if( metrics_->fullName_ != NullPtr< const char >( ) )
1057 {
1058 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1059 }
1060 typedef const Lang::String ValType;
1061 metrics_->fullName_ = Helpers::down_cast< ValType >( val, callLoc )->val_;
1062 }
1063 else if( strcmp( tag, "FamilyName" ) == 0 )
1064 {
1065 if( metrics_->familyName_ != NullPtr< const char >( ) )
1066 {
1067 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1068 }
1069 typedef const Lang::Symbol ValType;
1070 metrics_->familyName_ = Helpers::down_cast< ValType >( val, callLoc )->name( );
1071 }
1072 else if( strcmp( tag, "Weight" ) == 0 )
1073 {
1074 try
1075 {
1076 typedef const Lang::Symbol ValType;
1077 RefCountPtr< const char > typedVal = Helpers::try_cast_CoreArgument< ValType >( val )->name( );
1078 if( metrics_->weight_ != NullPtr< const char >( ) )
1079 {
1080 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1081 }
1082 static std::set< const char *, charPtrLess > legalStretchValues;
1083 if( legalStretchValues.empty( ) )
1084 {
1085 initializeLegalStrechValues( & legalStretchValues );
1086 }
1087 if( legalStretchValues.find( typedVal.getPtr( ) ) == legalStretchValues.end( ) )
1088 {
1089 throw Exceptions::OutOfRange( callLoc, "The 'Weight value is illegal. Please refer to the PDF specification." );
1090 }
1091 metrics_->weight_ = typedVal;
1092 goto OK;
1093 }
1094 catch( const NonLocalExit::NotThisType & ball )
1095 {
1096 /* Wrong type; never mind!.. but see below!
1097 */
1098 }
1099
1100 try
1101 {
1102 typedef const Lang::Integer ValType;
1103 RefCountPtr< ValType > casted_val = Helpers::try_cast_CoreArgument< ValType >( val );
1104 if( metrics_->weightNumber_ > 0 )
1105 {
1106 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1107 }
1108 if( casted_val->val_ % 100 != 0 )
1109 {
1110 throw Exceptions::OutOfRange( callLoc, "The 'Weight number must be divisible by 100." );
1111 }
1112 if( casted_val->val_ < 100 || casted_val->val_ > 900 )
1113 {
1114 throw Exceptions::OutOfRange( callLoc, "The 'Weight number must be in the range [ 100, 900 ]." );
1115 }
1116 metrics_->weightNumber_ = casted_val->val_;
1117 goto OK;
1118 }
1119 catch( const NonLocalExit::NotThisType & ball )
1120 {
1121 /* Wrong type; never mind!.. but see below!
1122 */
1123 }
1124
1125 throw Exceptions::TypeMismatch( callLoc, val->getTypeName( ), Helpers::typeSetString( Lang::String::staticTypeName( ), Lang::Integer::staticTypeName( ) ) );
1126 }
1127 else if( strcmp( tag, "Version" ) == 0 )
1128 {
1129 if( metrics_->version_ != NullPtr< const char >( ) )
1130 {
1131 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1132 }
1133 typedef const Lang::String ValType;
1134 metrics_->version_ = Helpers::down_cast< ValType >( val, callLoc )->val_;
1135 }
1136 else if( strcmp( tag, "Notice" ) == 0 )
1137 {
1138 if( metrics_->notice_ != NullPtr< const char >( ) )
1139 {
1140 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1141 }
1142 typedef const Lang::String ValType;
1143 metrics_->notice_ = Helpers::down_cast< ValType >( val, callLoc )->val_;
1144 }
1145 else if( strcmp( tag, "EncodingScheme" ) == 0 )
1146 {
1147 if( metrics_->encodingScheme_ != NullPtr< const char >( ) )
1148 {
1149 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1150 }
1151 typedef const Lang::Symbol ValType;
1152 metrics_->encodingScheme_ = Helpers::down_cast< ValType >( val, callLoc )->name( );
1153 }
1154 else if( strcmp( tag, "CharacterSet" ) == 0 )
1155 {
1156 if( metrics_->characterSet_ != NullPtr< const char >( ) )
1157 {
1158 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1159 }
1160 typedef const Lang::Symbol ValType;
1161 metrics_->characterSet_ = Helpers::down_cast< ValType >( val, callLoc )->name( );
1162 }
1163 else if( strcmp( tag, "Comment" ) == 0 )
1164 {
1165 typedef const Lang::String ValType;
1166 RefCountPtr< ValType > typedVal = Helpers::down_cast< ValType >( val, callLoc );
1167 metrics_->comments_.push_back( FontMetrics::AFM::AssortedInfo( tagMem, typedVal->val_ ) );
1168 }
1169 else if( strcmp( tag, "CapHeight" ) == 0 )
1170 {
1171 if( ! IS_NAN( metrics_->capHeight_ ) )
1172 {
1173 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1174 }
1175 if( ! ( size_ > 0 ) )
1176 {
1177 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1178 }
1179 typedef const Lang::Length ValType;
1180 metrics_->capHeight_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1181 }
1182 else if( strcmp( tag, "XHeight" ) == 0 )
1183 {
1184 if( ! IS_NAN( metrics_->xHeight_ ) )
1185 {
1186 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1187 }
1188 if( ! ( size_ > 0 ) )
1189 {
1190 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1191 }
1192 typedef const Lang::Length ValType;
1193 metrics_->xHeight_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1194 }
1195 else if( strcmp( tag, "Ascent" ) == 0 )
1196 {
1197 if( ! IS_NAN( metrics_->ascender_ ) )
1198 {
1199 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1200 }
1201 if( ! ( size_ > 0 ) )
1202 {
1203 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1204 }
1205 typedef const Lang::Length ValType;
1206 metrics_->ascender_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1207 }
1208 else if( strcmp( tag, "Descent" ) == 0 )
1209 {
1210 if( ! IS_NAN( metrics_->descender_ ) )
1211 {
1212 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1213 }
1214 if( ! ( size_ > 0 ) )
1215 {
1216 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1217 }
1218 typedef const Lang::Length ValType;
1219 metrics_->descender_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1220 }
1221 else if( strcmp( tag, "Leading" ) == 0 )
1222 {
1223 if( ! IS_NAN( metrics_->leading_ ) )
1224 {
1225 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1226 }
1227 if( ! ( size_ > 0 ) )
1228 {
1229 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1230 }
1231 typedef const Lang::Length ValType;
1232 metrics_->leading_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1233 }
1234 else if( strcmp( tag, "StemH" ) == 0 )
1235 {
1236 if( ! IS_NAN( metrics_->stdHW_ ) )
1237 {
1238 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1239 }
1240 if( ! ( size_ > 0 ) )
1241 {
1242 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1243 }
1244 typedef const Lang::Length ValType;
1245 metrics_->stdHW_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1246 }
1247 else if( strcmp( tag, "StemV" ) == 0 )
1248 {
1249 if( ! IS_NAN( metrics_->stdVW_ ) )
1250 {
1251 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1252 }
1253 if( ! ( size_ > 0 ) )
1254 {
1255 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1256 }
1257 typedef const Lang::Length ValType;
1258 metrics_->stdVW_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1259 }
1260 else if( strcmp( tag, "FontBBox" ) == 0 )
1261 {
1262 if( metrics_->fontBBoxXMax_ >= metrics_->fontBBoxXMin_ )
1263 {
1264 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1265 }
1266 if( ! ( size_ > 0 ) )
1267 {
1268 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1269 }
1270 typedef const Lang::ElementaryPath2D ValType;
1271 RefCountPtr< ValType > casted_val = Helpers::elementaryPathTry2D( val );
1272 Concrete::Coords2D llcorner( 0, 0 );
1273 Concrete::Coords2D urcorner( 0, 0 );
1274 if( ! casted_val->boundingRectangle( & llcorner, & urcorner ) )
1275 {
1276 throw Exceptions::OutOfRange( callLoc, "The path was empty." );
1277 }
1278 metrics_->fontBBoxXMin_ = llcorner.x_ / size_;
1279 metrics_->fontBBoxYMin_ = llcorner.y_ / size_;
1280 metrics_->fontBBoxXMax_ = urcorner.x_ / size_;
1281 metrics_->fontBBoxYMax_ = urcorner.y_ / size_;
1282 }
1283 else if( strcmp( tag, "UnderlinePosition" ) == 0 )
1284 {
1285 if( ! IS_NAN( horizontalMetrics_typed_->underlinePosition_ ) )
1286 {
1287 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1288 }
1289 if( ! ( size_ > 0 ) )
1290 {
1291 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1292 }
1293 typedef const Lang::Length ValType;
1294 horizontalMetrics_typed_->underlinePosition_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1295 }
1296 else if( strcmp( tag, "UnderlineThickness" ) == 0 )
1297 {
1298 if( ! IS_NAN( horizontalMetrics_typed_->underlineThickness_ ) )
1299 {
1300 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1301 }
1302 if( ! ( size_ > 0 ) )
1303 {
1304 throw Exceptions::OutOfRange( callLoc, "Please provide a value for 'size first." );
1305 }
1306 typedef const Lang::Length ValType;
1307 horizontalMetrics_typed_->underlineThickness_ = Helpers::down_cast< ValType >( val, callLoc )->get( ) / size_;
1308 }
1309 else if( strcmp( tag, "ItalicAngle" ) == 0 )
1310 {
1311 if( ! IS_NAN( horizontalMetrics_typed_->italicAngleRadians_ ) )
1312 {
1313 throw Exceptions::MiscellaneousRequirement( "Multiply specified value." );
1314 }
1315 typedef const Lang::Float ValType;
1316 horizontalMetrics_typed_->italicAngleRadians_ = Helpers::down_cast< ValType >( val, callLoc )->val_;
1317 }
1318 else
1319 {
1320 typedef const Lang::String ValType;
1321 RefCountPtr< ValType > typedVal = Helpers::down_cast< ValType >( val, callLoc );
1322 metrics_->assortedGlobalInfo_.push_back( FontMetrics::AFM::AssortedInfo( tagMem, typedVal->val_ ) );
1323 }
1324
1325 OK:
1326 Kernel::ContRef cont = evalState->cont_;
1327 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
1328 evalState );
1329 return;
1330 }
1331 catch( const NonLocalExit::NotThisType & ball )
1332 {
1333 /* Wrong type; never mind!.. but see below!
1334 */
1335 }
1336
1337 throw Exceptions::TypeMismatch( callLoc, piece->getTypeName( ), Helpers::typeSetString( Lang::Type3Glyph::staticTypeName( ), Lang::KernedText::staticTypeName( ), Lang::TaggedValue2D::staticTypeName( ) ) );
1338 }
1339
1340 void
1341 Kernel::WarmType3Font::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1342 {
1343 if( glyphs_.empty( ) )
1344 {
1345 throw Exceptions::OutOfRange( callLoc, "A font without glyphs?!" );
1346 }
1347 if( ! ( size_ > 0 ) )
1348 {
1349 throw Exceptions::OutOfRange( callLoc, "Missing 'size." );
1350 }
1351 if( strlen( metrics_->fontName_.getPtr( ) ) == 0 )
1352 {
1353 throw Exceptions::OutOfRange( callLoc, "Missing 'FontName." );
1354 }
1355 if( metrics_->weightNumber_ == 0 )
1356 {
1357 metrics_->weightNumber_ = 400;
1358 }
1359 bool findBBox = false;
1360 if( metrics_->fontBBoxXMax_ < metrics_->fontBBoxXMin_ )
1361 {
1362 findBBox = true;
1363 }
1364
1365 Concrete::ReciprocalLength invSize = 1 / size_;
1366
1367 metrics_->charCount_ = glyphs_.size( );
1368 metrics_->isCIDFont_ = false;
1369
1370 size_t firstChar = INT_MAX;
1371 size_t lastChar = 0;
1372 {
1373 // In the first scan of the glyphs, only firstChar and lastChar are computed. The other tasks are performed in the later scan.
1374 typedef typeof glyphs_ ListType;
1375 for( ListType::const_iterator i = glyphs_.begin( ); i != glyphs_.end( ); ++i )
1376 {
1377 size_t code = (*i)->code( );
1378 if( code > 0 )
1379 {
1380 firstChar = std::min( firstChar, code );
1381 lastChar = std::max( lastChar, code );
1382 }
1383 }
1384 }
1385
1386 RefCountPtr< SimplePDF::PDF_Vector > widths;
1387 {
1388 RefCountPtr< SimplePDF::PDF_Object > stdWidth = SimplePDF::newFloat( 0 );
1389 widths->vec.resize( lastChar - firstChar + 1, stdWidth );
1390 }
1391 RefCountPtr< SimplePDF::PDF_Dictionary > charProcs;
1392 RefCountPtr< SimplePDF::PDF_Resources > resources;
1393 // RefCountPtr< SimplePDF::PDF_Stream_out > toUnicode;
1394
1395 horizontalMetrics_typed_->charData_.reserve( glyphs_.size( ) );
1396
1397 {
1398 // This is the main loop over all glyphs.
1399 typedef typeof glyphs_ ListType;
1400 for( ListType::const_iterator i = glyphs_.begin( ); i != glyphs_.end( ); ++i )
1401 {
1402 size_t code = (*i)->code( );
1403 if( code > 0 )
1404 {
1405 widths->vec[ code - firstChar ] = SimplePDF::newFloat( (*i)->widthX( ) );
1406 }
1407
1408 RefCountPtr< SimplePDF::PDF_Stream_out > glyphStream;
1409 (*i)->shipout( glyphStream->data, resources );
1410 charProcs->dic[ (*i)->name( ).getPtr( ) ] = SimplePDF::indirect( glyphStream, & Kernel::theIndirectObjectCount );
1411
1412 size_t pos = horizontalMetrics_typed_->charData_.size( );
1413 FontMetrics::CharacterMetrics * glyphMetrics = new FontMetrics::CharacterMetrics( pos );
1414 (*i)->setupMetric( glyphMetrics, invSize );
1415 horizontalMetrics_typed_->charData_.push_back( glyphMetrics );
1416 horizontalMetrics_typed_->nameMap_[ (*i)->name( ) ] = pos;
1417 if( code > 0 )
1418 {
1419 horizontalMetrics_typed_->codeMap_[ code ] = pos;
1420 }
1421
1422 if( findBBox )
1423 {
1424 (*i)->enlargeBBox( & metrics_->fontBBoxXMin_, & metrics_->fontBBoxYMin_, & metrics_->fontBBoxXMax_, & metrics_->fontBBoxYMax_ );
1425 }
1426 }
1427 }
1428
1429 RefCountPtr< SimplePDF::PDF_Vector > fontBBox( new SimplePDF::PDF_Vector( metrics_->fontBBoxXMin_, metrics_->fontBBoxYMin_,
1430 metrics_->fontBBoxXMax_, metrics_->fontBBoxYMax_ ) );
1431 RefCountPtr< SimplePDF::PDF_Dictionary > fontDescriptor;
1432 (*fontDescriptor)[ "Type" ] = SimplePDF::newName( "FontDescriptor" );
1433 (*fontDescriptor)[ "FontName" ] = SimplePDF::newName( metrics_->fontName_.getPtr( ) );
1434 if( metrics_->familyName_.getPtr( ) != NullPtr< const char >( ) )
1435 {
1436 (*fontDescriptor)[ "FontFamily" ] = SimplePDF::newName( metrics_->familyName_.getPtr( ) );
1437 }
1438 if( metrics_->weight_.getPtr( ) != NullPtr< const char >( ) )
1439 {
1440 // It has already been asserted that this value is legal.
1441 (*fontDescriptor)[ "FontStretch" ] = SimplePDF::newName( metrics_->weight_.getPtr( ) );
1442 }
1443 if( metrics_->weightNumber_ > 0 )
1444 {
1445 // It has already been asserted that this value is legal.
1446 (*fontDescriptor)[ "FontWeight" ] = SimplePDF::newInt( metrics_->weightNumber_ );
1447 }
1448 (*fontDescriptor)[ "Flags" ] = SimplePDF::newInt( (size_t)(1) << ( 6 - 1 ) ); // This is just the "Nonsymbolic" flag.
1449 (*fontDescriptor)[ "FontBBox" ] = fontBBox;
1450 if( ! IS_NAN( horizontalMetrics_typed_->italicAngleRadians_ ) )
1451 {
1452 (*fontDescriptor)[ "ItalicAngle" ] = SimplePDF::newFloat( ( 180 / M_PI ) * horizontalMetrics_typed_->italicAngleRadians_ );
1453 }
1454 else
1455 {
1456 throw Exceptions::OutOfRange( callLoc, "Missing 'ItalicAngle." );
1457 }
1458 if( ! IS_NAN( metrics_->ascender_ ) )
1459 {
1460 (*fontDescriptor)[ "Ascent" ] = SimplePDF::newFloat( metrics_->ascender_ );
1461 }
1462 if( ! IS_NAN( metrics_->descender_ ) )
1463 {
1464 (*fontDescriptor)[ "Descent" ] = SimplePDF::newFloat( metrics_->descender_ );
1465 }
1466 if( ! IS_NAN( metrics_->leading_ ) )
1467 {
1468 (*fontDescriptor)[ "Leading" ] = SimplePDF::newFloat( metrics_->leading_ );
1469 }
1470 if( ! IS_NAN( metrics_->capHeight_ ) )
1471 {
1472 (*fontDescriptor)[ "CapHeight" ] = SimplePDF::newFloat( metrics_->capHeight_ );
1473 }
1474 if( ! IS_NAN( metrics_->xHeight_ ) )
1475 {
1476 (*fontDescriptor)[ "XHeight" ] = SimplePDF::newFloat( metrics_->xHeight_ );
1477 }
1478 if( ! IS_NAN( metrics_->stdHW_ ) )
1479 {
1480 (*fontDescriptor)[ "StemH" ] = SimplePDF::newFloat( metrics_->stdHW_ );
1481 }
1482 if( ! IS_NAN( metrics_->stdVW_ ) )
1483 {
1484 (*fontDescriptor)[ "StemV" ] = SimplePDF::newFloat( metrics_->stdVW_ );
1485 }
1486
1487 Concrete::Length the1bp( 1 );
1488
1489 RefCountPtr< SimplePDF::PDF_Dictionary > dic;
1490 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( dic, & Kernel::theIndirectObjectCount );
1491 (*dic)[ "Type" ] = SimplePDF::newName( "Font" );
1492 (*dic)[ "Subtype" ] = SimplePDF::newName( "Type3" );
1493 (*dic)[ "Encoding" ] = SimplePDF::newName( "MacRomanEncoding" );
1494 (*dic)[ "FontBBox" ] = fontBBox;
1495 (*dic)[ "FontMatrix" ] = RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( the1bp * invSize, 0, 0, the1bp * invSize, 0, 0 ) );
1496 (*dic)[ "CharProcs" ] = charProcs;
1497 (*dic)[ "FirstChar" ] = SimplePDF::newInt( firstChar );
1498 (*dic)[ "LastChar" ] = SimplePDF::newInt( lastChar );
1499 (*dic)[ "Widths" ] = widths;
1500 (*dic)[ "FontDescriptor" ] = fontDescriptor;
1501 (*dic)[ "Resources" ] = SimplePDF::indirect( resources, & Kernel::theIndirectObjectCount );
1502
1503 // {
1504 // static bool shown = false;
1505 // if( ! shown )
1506 // {
1507 // WARN_OR_THROW( Shapes::Exceptions::InternalError( "The ToUnicode CMap is not set up by Shapes.", true ) );
1508 // shown = true;
1509 // }
1510 // }
1511 // (*dic)[ "ToUnicode" ] = toUnicode;
1512
1513 Kernel::ContRef cont = evalState->cont_;
1514 cont->takeValue( Kernel::ValueRef( new Lang::Type3Font( metrics_->fontName_,
1515 indirection,
1516 metrics_ ) ),
1517 evalState );
1518 }
1519
1520 void
1521 Kernel::WarmType3Font::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1522 {
1523 throw Exceptions::MiscellaneousRequirement( strrefdup( "A type 3 font state cannot be peeked." ) );
1524 }
1525
1526 void
1527 Kernel::WarmType3Font::gcMark( Kernel::GCMarkedSet & marked )
1528 {
1529 {
1530 typedef typeof kernings_ ListType;
1531 for( ListType::const_iterator i = kernings_.begin( ); i != kernings_.end( ); ++i )
1532 {
1533 const_cast< Lang::KernedText * >( i->getPtr( ) )->gcMark( marked );
1534 }
1535 }
1536 {
1537 typedef typeof glyphs_ ListType;
1538 for( ListType::const_iterator i = glyphs_.begin( ); i != glyphs_.end( ); ++i )
1539 {
1540 const_cast< Lang::Type3Glyph * >( i->getPtr( ) )->gcMark( marked );
1541 }
1542 }
1543 }
1544
1545
1546 void
1547 Kernel::WarmType3Font::initializeLegalStrechValues( std::set< const char *, charPtrLess > * legalStretchValues )
1548 {
1549 legalStretchValues->insert( "UltraCondensed" );
1550 legalStretchValues->insert( "ExtraCondensed" );
1551 legalStretchValues->insert( "Condensed" );
1552 legalStretchValues->insert( "SemiCondensed" );
1553 legalStretchValues->insert( "Normal" );
1554 legalStretchValues->insert( "SemiExpanded" );
1555 legalStretchValues->insert( "Expanded" );
1556 legalStretchValues->insert( "ExtraExpanded" );
1557 legalStretchValues->insert( "UltraExpanded" );
1558 }
1559
1560
1561 Kernel::WarmRandomDevice::WarmRandomDevice( const char * deviceName )
1562 : deviceName_( deviceName )
1563 { }
1564
1565 Kernel::WarmRandomDevice::~WarmRandomDevice( )
1566 { }
1567
1568 RefCountPtr< const Lang::Class > Kernel::WarmRandomDevice::TypeID( new Lang::SystemFinalClass( strrefdup( "#RandomDevice" ) ) );
1569 TYPEINFOIMPL_STATE( WarmRandomDevice );
1570
1571 void
1572 Kernel::WarmRandomDevice::read( char * dst, size_t sz )
1573 {
1574 if( ! idev_.is_open( ) )
1575 {
1576 idev_.open( deviceName_ );
1577 if( ! idev_.is_open( ) || ! idev_.good( ) )
1578 {
1579 throw Exceptions::ExternalError( strrefdup( deviceName_ + std::string( " could not be opened for input." ) ) );
1580 }
1581 }
1582
1583 idev_.read( dst, sz );
1584 }
1585
1586 void
1587 Kernel::WarmRandomDevice::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
1588 {
1589 if( ! odev_.is_open( ) )
1590 {
1591 odev_.open( deviceName_ );
1592 if( ! odev_.is_open( ) || ! odev_.good( ) )
1593 {
1594 throw Exceptions::ExternalError( strrefdup( deviceName_ + std::string( " could not be opened for output." ) ) );
1595 }
1596 }
1597
1598 piece->show( odev_ );
1599 Kernel::ContRef cont = evalState->cont_;
1600 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
1601 evalState );
1602 }
1603
1604 void
1605 Kernel::WarmRandomDevice::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1606 {
1607 throw Exceptions::MiscellaneousRequirement( strrefdup( "The random device cannot be frozen." ) );
1608 }
1609
1610 void
1611 Kernel::WarmRandomDevice::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1612 {
1613 if( ! idev_.is_open( ) )
1614 {
1615 idev_.open( deviceName_ );
1616 if( ! idev_.is_open( ) || ! idev_.good( ) )
1617 {
1618 throw Exceptions::ExternalError( strrefdup( deviceName_ + std::string( " could not be opened for output." ) ) );
1619 }
1620 }
1621
1622 unsigned char tmp;
1623 idev_.read( reinterpret_cast< char * >( & tmp ), 1 );
1624 Kernel::ContRef cont = evalState->cont_;
1625 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::Integer( tmp ) ),
1626 evalState );
1627 }
1628
1629 void
1630 Kernel::WarmRandomDevice::gcMark( Kernel::GCMarkedSet & marked )
1631 { }
1632
1633
1634 Kernel::WarmTime::WarmTime( )
1635 { }
1636
1637 Kernel::WarmTime::~WarmTime( )
1638 { }
1639
1640 RefCountPtr< const Lang::Class > Kernel::WarmTime::TypeID( new Lang::SystemFinalClass( strrefdup( "#Time" ) ) );
1641 TYPEINFOIMPL_STATE( WarmTime );
1642
1643 void
1644 Kernel::WarmTime::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
1645 {
1646 throw Exceptions::MiscellaneousRequirement( strrefdup( "The time does not accept values." ) );
1647 }
1648
1649 void
1650 Kernel::WarmTime::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1651 {
1652 throw Exceptions::MiscellaneousRequirement( strrefdup( "The time cannot be frozen." ) );
1653 }
1654
1655 void
1656 Kernel::WarmTime::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1657 {
1658 time_t t = time( 0 );
1659 Kernel::ContRef cont = evalState->cont_;
1660 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::ChronologicalTime( t ) ),
1661 evalState );
1662 }
1663
1664 void
1665 Kernel::WarmTime::gcMark( Kernel::GCMarkedSet & marked )
1666 { }
1667
1668
1669 Kernel::WarmRandomState::WarmRandomState( char * state )
1670 : state_( state )
1671 { }
1672
1673 Kernel::WarmRandomState::~WarmRandomState( )
1674 {
1675 delete state_; // Let's hope this is not in use!
1676 }
1677
1678 RefCountPtr< const Lang::Class > Kernel::WarmRandomState::TypeID( new Lang::SystemFinalClass( strrefdup( "#RandomState" ) ) );
1679 TYPEINFOIMPL_STATE( WarmRandomState );
1680
1681 void
1682 Kernel::WarmRandomState::setState( )
1683 {
1684 setstate( state_ );
1685 }
1686
1687 void
1688 Kernel::WarmRandomState::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
1689 {
1690 throw Exceptions::MiscellaneousRequirement( strrefdup( "A random state does not accept values." ) );
1691 }
1692
1693 void
1694 Kernel::WarmRandomState::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1695 {
1696 throw Exceptions::MiscellaneousRequirement( strrefdup( "A random state cannot be frozen." ) );
1697 }
1698
1699 void
1700 Kernel::WarmRandomState::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1701 {
1702 setState( );
1703 long tmp = random( );
1704 Kernel::ContRef cont = evalState->cont_;
1705 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::Integer( tmp ) ),
1706 evalState );
1707 }
1708
1709 void
1710 Kernel::WarmRandomState::gcMark( Kernel::GCMarkedSet & marked )
1711 { }
1712
1713
1714 Kernel::WarmColorInterpolator::WarmColorInterpolator( )
1715 : hasKey_( false ), colorType_( Lang::ColorInterpolator::UNDEFINED )
1716 { }
1717
1718 Kernel::WarmColorInterpolator::~WarmColorInterpolator( )
1719 { }
1720
1721 RefCountPtr< const Lang::Class > Kernel::WarmColorInterpolator::TypeID( new Lang::SystemFinalClass( strrefdup( "#ColorInterpolator" ) ) );
1722 TYPEINFOIMPL_STATE( WarmColorInterpolator );
1723
1724 void
1725 Kernel::WarmColorInterpolator::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
1726 {
1727 if( hasKey_ )
1728 {
1729 switch( colorType_ )
1730 {
1731 case Lang::ColorInterpolator::UNDEFINED:
1732 try
1733 {
1734 RGBcolor_->push_back( Helpers::down_cast< const Lang::RGB >( piece, callLoc )->components( ) );
1735 colorType_ = Lang::ColorInterpolator::RGB;
1736 break;
1737 }
1738 catch( const Exceptions::TypeMismatch & )
1739 {
1740 }
1741 try
1742 {
1743 graycolor_->push_back( Helpers::down_cast< const Lang::Gray >( piece, callLoc )->components( ) );
1744 colorType_ = Lang::ColorInterpolator::GRAY;
1745 break;
1746 }
1747 catch( const Exceptions::TypeMismatch & )
1748 {
1749 }
1750 try
1751 {
1752 CMYKcolor_->push_back( Helpers::down_cast< const Lang::CMYK >( piece, callLoc )->components( ) );
1753 colorType_ = Lang::ColorInterpolator::CMYK;
1754 break;
1755 }
1756 catch( const Exceptions::TypeMismatch & )
1757 {
1758 throw Exceptions::MiscellaneousRequirement( strrefdup( "Only colors can be passed to an interpolator." ) );
1759 }
1760 case Lang::ColorInterpolator::RGB:
1761 RGBcolor_->push_back( Helpers::down_cast< const Lang::RGB >( piece, callLoc )->components( ) );
1762 break;
1763
1764 case Lang::ColorInterpolator::GRAY:
1765 graycolor_->push_back( Helpers::down_cast< const Lang::Gray >( piece, callLoc )->components( ) );
1766 break;
1767
1768 case Lang::ColorInterpolator::CMYK:
1769 CMYKcolor_->push_back( Helpers::down_cast< const Lang::CMYK >( piece, callLoc )->components( ) );
1770 break;
1771 }
1772 }
1773 else
1774 {
1775 typedef const Lang::Float ArgType;
1776 double key = Helpers::down_cast< ArgType >( piece, callLoc )->val_;
1777 if( !key_->empty( ) && key < key_->back( ) )
1778 {
1779 throw Exceptions::MiscellaneousRequirement( strrefdup( "Keys must be added in nondecreasing order to an interpolator." ) );
1780 }
1781 else
1782 {
1783 key_->push_back( key );
1784 }
1785 }
1786
1787 hasKey_ = ! hasKey_;
1788
1789 Kernel::ContRef cont = evalState->cont_;
1790 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
1791 evalState );
1792 }
1793
1794 void
1795 Kernel::WarmColorInterpolator::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1796 {
1797 if( key_->empty( ) )
1798 {
1799 throw Exceptions::MiscellaneousRequirement( strrefdup( "There are no colors that define the interpolation." ) );
1800 }
1801 if( hasKey_ )
1802 {
1803 throw Exceptions::MiscellaneousRequirement( strrefdup( "Missing color for the last key." ) );
1804 }
1805
1806 Kernel::ContRef cont = evalState->cont_;
1807 cont->takeValue( RefCountPtr< const Lang::Value >( new Lang::ColorInterpolator( key_, RGBcolor_, graycolor_, CMYKcolor_, colorType_ ) ),
1808 evalState );
1809 }
1810
1811 void
1812 Kernel::WarmColorInterpolator::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
1813 {
1814 throw Exceptions::MiscellaneousRequirement( strrefdup( "An interpolator cannot be peeked." ) );
1815 }
1816
1817 void
1818 Kernel::WarmColorInterpolator::gcMark( Kernel::GCMarkedSet & marked )
1819 { }
1820
1821
1822 namespace Shapes
1823 {
1824 namespace Kernel
1825 {
1826
1827 class Mutator_vector_size : public Lang::CoreMutator
1828 {
1829 public:
1830 Mutator_vector_size( const char * name )
1831 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1832 {
1833 }
1834 virtual void
1835 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1836 {
1837 args.applyDefaults( callLoc );
1838
1839 typedef Warm_vector StateType;
1840 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
1841
1842 Kernel::ContRef cont = evalState->cont_;
1843 cont->takeValue( Kernel::ValueRef( new Lang::Integer( state->mem_->size( ) ) ),
1844 evalState );
1845 }
1846 };
1847
1848 class Mutator_vector_resize : public Lang::CoreMutator
1849 {
1850 public:
1851 Mutator_vector_resize( const char * name )
1852 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1853 {
1854 formals_->appendEvaluatedCoreFormal( "size", Kernel::THE_SLOT_VARIABLE );
1855 formals_->appendEvaluatedCoreFormal( "fill", Kernel::THE_VOID_VARIABLE );
1856 }
1857 virtual void
1858 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1859 {
1860 args.applyDefaults( callLoc );
1861
1862 typedef Warm_vector StateType;
1863 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
1864
1865 typedef const Lang::Integer IndexType;
1866 IndexType::ValueType tmp = Helpers::down_cast_MutatorArgument< IndexType >( state, name_, args, 0, callLoc )->val_;
1867 if( tmp < 0 )
1868 {
1869 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The size must be non-negative." );
1870 }
1871 size_t newSize = static_cast< size_t >( tmp );
1872
1873 if( newSize < state->mem_->size( ) )
1874 {
1875 while( newSize < state->mem_->size( ) )
1876 {
1877 state->mem_->pop_back( );
1878 }
1879 }
1880 else
1881 {
1882 state->mem_->reserve( newSize );
1883 RefCountPtr< const Lang::Value > fill = args.getValue( 1 );
1884 while( newSize > state->mem_->size( ) )
1885 {
1886 state->mem_->push_back( fill );
1887 }
1888 }
1889
1890 Kernel::ContRef cont = evalState->cont_;
1891 cont->takeValue( Lang::THE_VOID,
1892 evalState );
1893 }
1894 };
1895
1896 class Mutator_vector_reserve : public Lang::CoreMutator
1897 {
1898 public:
1899 Mutator_vector_reserve( const char * name )
1900 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1901 {
1902 formals_->appendEvaluatedCoreFormal( "size", Kernel::THE_SLOT_VARIABLE );
1903 }
1904 virtual void
1905 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1906 {
1907 args.applyDefaults( callLoc );
1908
1909 typedef Warm_vector StateType;
1910 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
1911
1912 typedef const Lang::Integer IndexType;
1913 IndexType::ValueType tmp = Helpers::down_cast_MutatorArgument< IndexType >( state, name_, args, 0, callLoc )->val_;
1914 if( tmp < 0 )
1915 {
1916 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The size must be non-negative." );
1917 }
1918 size_t newSize = static_cast< size_t >( tmp );
1919
1920 state->mem_->reserve( newSize );
1921
1922 Kernel::ContRef cont = evalState->cont_;
1923 cont->takeValue( Lang::THE_VOID,
1924 evalState );
1925 }
1926 };
1927
1928 class Mutator_vector_set : public Lang::CoreMutator
1929 {
1930 public:
1931 Mutator_vector_set( const char * name )
1932 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1933 {
1934 formals_->appendEvaluatedCoreFormal( "index", Kernel::THE_SLOT_VARIABLE );
1935 formals_->appendEvaluatedCoreFormal( "value", Kernel::THE_SLOT_VARIABLE );
1936 }
1937 virtual void
1938 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1939 {
1940 args.applyDefaults( callLoc );
1941
1942 typedef Warm_vector StateType;
1943 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
1944
1945 typedef const Lang::Integer IndexType;
1946 IndexType::ValueType tmp = Helpers::down_cast_MutatorArgument< IndexType >( state, name_, args, 0, callLoc )->val_;
1947 if( tmp < 0 )
1948 {
1949 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The index must be non-negative." );
1950 }
1951 size_t index = static_cast< size_t >( tmp );
1952 if( index >= state->mem_->size( ) )
1953 {
1954 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The index is out of range." );
1955 }
1956
1957 (*state->mem_)[ index ] = args.getValue( 1 );
1958
1959 Kernel::ContRef cont = evalState->cont_;
1960 cont->takeValue( Lang::THE_VOID,
1961 evalState );
1962 }
1963 };
1964
1965 class Mutator_vector_get : public Lang::CoreMutator
1966 {
1967 public:
1968 Mutator_vector_get( const char * name )
1969 : CoreMutator( name, new Kernel::EvaluatedFormals( Ast::FileID::build_internal( name ), true ) )
1970 {
1971 formals_->appendEvaluatedCoreFormal( "index", Kernel::THE_SLOT_VARIABLE );
1972 }
1973 virtual void
1974 call( Kernel::EvalState * evalState, Kernel::Arguments & args, const Ast::SourceLocation & callLoc ) const
1975 {
1976 args.applyDefaults( callLoc );
1977
1978 typedef Warm_vector StateType;
1979 StateType * state = Helpers::mutator_cast_self< StateType >( args.getMutatorSelf( ) );
1980
1981 typedef const Lang::Integer IndexType;
1982 IndexType::ValueType tmp = Helpers::down_cast_MutatorArgument< IndexType >( state, name_, args, 0, callLoc )->val_;
1983 if( tmp < 0 )
1984 {
1985 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The index must be non-negative." );
1986 }
1987 size_t index = static_cast< size_t >( tmp );
1988 if( index >= state->mem_->size( ) )
1989 {
1990 throw Exceptions::CoreOutOfRange( new Interaction::MutatorLocation( state, name_ ), args, 0, "The index is out of range." );
1991 }
1992
1993 Kernel::ContRef cont = evalState->cont_;
1994 cont->takeValue( (*state->mem_)[ index ],
1995 evalState );
1996 }
1997 };
1998
1999 }
2000 }
2001
2002 Kernel::Warm_vector::Warm_vector( )
2003 : mem_( new std::vector< Kernel::ValueRef > )
2004 { }
2005
2006 Kernel::Warm_vector::~Warm_vector( )
2007 {
2008 if( mem_ != 0 )
2009 {
2010 delete mem_;
2011 }
2012 }
2013
2014 void
2015 WarmVector_register_mutators( Lang::SystemFinalClass * dstClass )
2016 {
2017 dstClass->registerMutator( new Kernel::Mutator_vector_size( "size" ) );
2018 dstClass->registerMutator( new Kernel::Mutator_vector_resize( "resize" ) );
2019 dstClass->registerMutator( new Kernel::Mutator_vector_reserve( "reserve" ) );
2020 dstClass->registerMutator( new Kernel::Mutator_vector_set( "set" ) );
2021 dstClass->registerMutator( new Kernel::Mutator_vector_get( "get" ) );
2022 }
2023
2024 RefCountPtr< const Lang::Class > Kernel::Warm_vector::TypeID( new Lang::SystemFinalClass( strrefdup( "#Array" ), WarmVector_register_mutators ) );
2025 TYPEINFOIMPL_STATE( Warm_vector );
2026
2027 void
2028 Kernel::Warm_vector::tackOnImpl( Kernel::EvalState * evalState, const RefCountPtr< const Lang::Value > & piece, const Ast::SourceLocation & callLoc )
2029 {
2030 mem_->push_back( piece );
2031 Kernel::ContRef cont = evalState->cont_;
2032 cont->takeHandle( Kernel::THE_VOID_VARIABLE,
2033 evalState );
2034 }
2035
2036 void
2037 Kernel::Warm_vector::freezeImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
2038 {
2039 Kernel::ContRef cont = evalState->cont_;
2040 cont->takeValue( Kernel::ValueRef( new Lang::VectorFunction( mem_ ) ),
2041 evalState );
2042 mem_ = 0; /* The VectorFunction owns the memory now. */
2043 }
2044
2045 void
2046 Kernel::Warm_vector::peekImpl( Kernel::EvalState * evalState, const Ast::SourceLocation & callLoc )
2047 {
2048 throw Exceptions::MiscellaneousRequirement( strrefdup( "An array state cannot be peeked. To inspect one entry at at time, use the <get> mutator." ) );
2049 }
2050
2051 void
2052 Kernel::Warm_vector::gcMark( Kernel::GCMarkedSet & marked )
2053 { }
2054
2055
2056 void
2057 Kernel::registerHot( Kernel::Environment * env )
2058 {
2059 env->initDefine( Lang::CANVAS_ID, new Kernel::WarmGroup2D );
2060 env->initDefine( Lang::CATALOG_ID, new Kernel::WarmCatalog );
2061 env->initDefine( Lang::THE_NAMESPACE_Shapes_IO, "stdout", new Kernel::WarmOstream( std::cout ) );
2062 env->initDefine( Lang::THE_NAMESPACE_Shapes_IO, "stderr", new Kernel::WarmOstream( std::cerr ) );
2063 env->initDefine( Lang::THE_NAMESPACE_Shapes_Numeric_Random, "randomdevice", new Kernel::WarmRandomDevice( "/dev/urandom" ) );
2064 env->initDefine( Lang::THE_NAMESPACE_Shapes, "time", new Kernel::WarmTime );
2065 env->initDefine( Lang::THE_NAMESPACE_Shapes, "ignore", new Kernel::WarmIgnore );
2066
2067 env->initDefine( Lang::THE_NAMESPACE_Shapes, "newIgnore", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmIgnore > ) );
2068 env->initDefine( Lang::THE_NAMESPACE_Shapes_Graphics, "newGroup", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmGroup2D > ) );
2069 env->initDefine( Lang::THE_NAMESPACE_Shapes_Graphics3D, "newGroup", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmGroup3D > ) );
2070 env->initDefine( Lang::THE_NAMESPACE_Shapes_Graphics3D, "newZBuf", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmZBuf > ) );
2071 env->initDefine( Lang::THE_NAMESPACE_Shapes_Graphics3D, "newZSorter", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmZSorter > ) );
2072 env->initDefine( Lang::THE_NAMESPACE_Shapes_Graphics3D, "newLights", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmGroupLights > ) );
2073 env->initDefine( Lang::THE_NAMESPACE_Shapes_String, "newString", Kernel::ValueRef( new Lang::HotDefault< Kernel::Warm_ostringstream > ) );
2074 env->initDefine( Lang::THE_NAMESPACE_Shapes, "newTimer", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmTimer > ) );
2075 env->initDefine( Lang::THE_NAMESPACE_Shapes_Text, "newText", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmText > ) );
2076 env->initDefine( Lang::THE_NAMESPACE_Shapes_Text, "newFont", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmType3Font > ) );
2077 env->initDefine( Lang::THE_NAMESPACE_Shapes_Traits, "newColorInterpolator", Kernel::ValueRef( new Lang::HotDefault< Kernel::WarmColorInterpolator > ) );
2078 env->initDefine( Lang::THE_NAMESPACE_Shapes_Data, "newArray", Kernel::ValueRef( new Lang::HotDefault< Kernel::Warm_vector > ) );
2079 }
Graphics language