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