source/pdfstructure.cc

   1 /* This file is part of Shapes.
   2  *
   3  * Shapes is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * any later version.
   7  *
   8  * Shapes is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with Shapes.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright 2008 Henrik Tidefelt
  17  */
  18
  19 #include <iomanip>
  20 #include <cstdlib>
  21 #include <cstring>
  22 #include <cstdio>
  23 #include <zlib.h>
  24
  25 #include "pdfstructure.h"
  26 #include "simplepdfo.h"
  27 #include "simplepdfi.h"
  28 #include "check.h"
  29 #include "autoonoff.h"
  30
  31 using namespace std;
  32
  33 using namespace SimplePDF;
  34
  35 /****************/
  36
  37 SimplePDF::PDF_Object::PDF_Object( )
  38         : complete( false )
  39 { }
  40 SimplePDF::PDF_Object::~PDF_Object( )
  41 { }
  42 void
  43 SimplePDF::PDF_Object::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
  44 {
  45         throw "This function, PDF_Object::writeTo, must not be called.  It is practically purely virtual.";
  46 }
  47 RefCountPtr< PDF_Object >
  48 SimplePDF::PDF_Object::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
  49 {
  50         return self;
  51 }
  52
  53 /****************/
  54
  55 template< class S >
  56 RefCountPtr< S >
  57 SimplePDF::down_cast_follow( RefCountPtr< PDF_Object > maybeIndirect )
  58 {
  59         {
  60                 const PDF_Indirect_in * theIndirect( dynamic_cast< const PDF_Indirect_in * >( maybeIndirect.getPtr( ) ) );
  61                 if( theIndirect != 0 )
  62                         {
  63                                 return theIndirect->PDFin->follow< S >( maybeIndirect );
  64                         }
  65         }
  66         {
  67                 const PDF_Indirect_out * theIndirect( dynamic_cast< const PDF_Indirect_out * >( maybeIndirect.getPtr( ) ) );
  68                 if( theIndirect != 0 )
  69                         {
  70                                 return SimplePDF::down_cast_follow< S >( theIndirect->obj );
  71                         }
  72         }
  73
  74         return maybeIndirect.down_cast< S >( );
  75 }
  76
  77 namespace SimplePDF
  78 {
  79         template< >
  80         RefCountPtr< SimplePDF::PDF_Float >
  81         down_cast_follow< SimplePDF::PDF_Float >( RefCountPtr< PDF_Object > maybeIndirect )
  82         {
  83                 {
  84                         const PDF_Indirect_in * theIndirect( dynamic_cast< const PDF_Indirect_in * >( maybeIndirect.getPtr( ) ) );
  85                         if( theIndirect != 0 )
  86                                 {
  87                                         return theIndirect->PDFin->follow< SimplePDF::PDF_Float >( maybeIndirect );
  88                                 }
  89                 }
  90                 {
  91                         const PDF_Indirect_out * theIndirect( dynamic_cast< const PDF_Indirect_out * >( maybeIndirect.getPtr( ) ) );
  92                         if( theIndirect != 0 )
  93                                 {
  94                                         return SimplePDF::down_cast_follow< SimplePDF::PDF_Float >( theIndirect->obj );
  95                                 }
  96                 }
  97                 {
  98                         RefCountPtr< PDF_Int > res( maybeIndirect.down_cast< PDF_Int >( ) );
  99                         if( res != NullPtr< PDF_Int >( ) )
 100                                 {
 101                                         return RefCountPtr< PDF_Float >( new PDF_Float( res->value( ) ) );
 102                                 }
 103                 }
 104                 return maybeIndirect.down_cast< SimplePDF::PDF_Float >( );
 105         }
 106 }
 107
 108 namespace SimplePDF
 109 {
 110         template RefCountPtr< SimplePDF::PDF_Vector > down_cast_follow< SimplePDF::PDF_Vector >( RefCountPtr< PDF_Object > );
 111 }
 112
 113 /****************/
 114
 115 SimplePDF::PDF_Null::PDF_Null( )
 116 { }
 117 SimplePDF::PDF_Null::~PDF_Null( )
 118 { }
 119
 120 void
 121 SimplePDF::PDF_Null::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 122 {
 123         os << "null" ;
 124 }
 125
 126 /****************/
 127
 128 SimplePDF::PDF_Boolean::PDF_Boolean( ValueType _value )
 129         : my_value( _value )
 130 { }
 131 SimplePDF::PDF_Boolean::~PDF_Boolean( )
 132 { }
 133
 134 SimplePDF::PDF_Boolean::ValueType
 135 SimplePDF::PDF_Boolean::value( ) const
 136 {
 137         return my_value;
 138 }
 139
 140 void
 141 SimplePDF::PDF_Boolean::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 142 {
 143         if( my_value )
 144                 {
 145                         os << "true" ;
 146                 }
 147         else
 148                 {
 149                         os << "false" ;
 150                 }
 151 }
 152
 153 /****************/
 154
 155 SimplePDF::PDF_Int::PDF_Int( PDF_Int::ValueType _value )
 156         : my_value( _value )
 157 { }
 158 SimplePDF::PDF_Int::PDF_Int( const char * strvalue )
 159 {
 160         /* How can it be that end shall be non-const, while strvalue is const? */
 161         //      const char * end;
 162         char * end;
 163         my_value = strtol( strvalue, & end, 10 );
 164         if( *end != '\0' )
 165                 {
 166                         throw "Internal error: Bad numeric int format";
 167                 }
 168 }
 169 SimplePDF::PDF_Int::~PDF_Int( )
 170 { }
 171
 172 PDF_Int::ValueType
 173 SimplePDF::PDF_Int::value( ) const
 174 {
 175         return my_value;
 176 }
 177
 178 void
 179 SimplePDF::PDF_Int::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 180 {
 181         os << my_value ;
 182 }
 183
 184 /****************/
 185
 186 SimplePDF::PDF_Float::PDF_Float( PDF_Float::ValueType _value )
 187         : my_value( _value )
 188 { }
 189 SimplePDF::PDF_Float::PDF_Float( const char * strvalue )
 190 {
 191         /* How can it be that end shall be non-const, while strvalue is const? */
 192         //      const char * end;
 193         char * end;
 194         my_value = strtod( strvalue, & end );
 195         if( *end != '\0' )
 196                 {
 197                         throw( "Internal error: Bad numeric float format" );
 198                 }
 199 }
 200 SimplePDF::PDF_Float::~PDF_Float( )
 201 { }
 202
 203 SimplePDF::PDF_Float::ValueType PDF_Float::value( ) const
 204 {
 205         return my_value;
 206 }
 207
 208 void
 209 SimplePDF::PDF_Float::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 210 {
 211         os << my_value ;
 212 }
 213
 214 /****************/
 215
 216 SimplePDF::PDF_String::PDF_String( )
 217 { }
 218 SimplePDF::PDF_String::~PDF_String( )
 219 { }
 220
 221 /****************/
 222
 223 SimplePDF::PDF_LiteralString::PDF_LiteralString( const string & _str )
 224         : my_str( _str )
 225 { }
 226 SimplePDF::PDF_LiteralString::PDF_LiteralString( const char * _str )
 227         : my_str( _str )
 228 { }
 229 SimplePDF::PDF_LiteralString::PDF_LiteralString( const list< RefCountPtr< char > > & strs )
 230 {
 231         size_t length( 0 );
 232         typedef list< RefCountPtr< char > >::const_iterator I;
 233         for( I i( strs.begin( ) ); i != strs.end( ); ++i )
 234                 {
 235                         length += strlen( i->getPtr( ) );
 236                 }
 237         RefCountPtr< char > mem( new char[ length + 1 ] );
 238         char * dst = mem.getPtr( );
 239         for( I i( strs.begin( ) ); i != strs.end( ); ++i )
 240                 {
 241                         strcpy( dst, i->getPtr( ) );
 242                         dst += strlen( i->getPtr( ) );
 243                 }
 244         *dst = '\0';
 245         my_str = mem.getPtr( );
 246 }
 247 SimplePDF::PDF_LiteralString::~PDF_LiteralString( )
 248 { }
 249
 250 const string &
 251 SimplePDF::PDF_LiteralString::str( ) const
 252 {
 253         return my_str;
 254 }
 255
 256 void
 257 SimplePDF::PDF_LiteralString::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 258 {
 259         os << "(" ;
 260         for( const char * src = my_str.c_str( ); *src != '\0'; ++src )
 261                 {
 262                         switch( *src )
 263                                 {
 264                                 case '(':
 265                                         os << "\\(" ;
 266                                         break;
 267                                 case ')':
 268                                         os << "\\)" ;
 269                                         break;
 270                                 case '\\':
 271                                         os << "\\\\" ;
 272                                         break;
 273                                 default:
 274                                         os << *src ;
 275                                 }
 276                 }
 277         os << ")" ;
 278 }
 279
 280 /****************/
 281
 282 SimplePDF::PDF_HexString::PDF_HexString( const string & _hexstr )
 283         : my_hexstr( _hexstr )
 284 { }
 285 SimplePDF::PDF_HexString::PDF_HexString( const char * _hexstr )
 286         : my_hexstr( _hexstr )
 287 { }
 288 SimplePDF::PDF_HexString::~PDF_HexString( )
 289 { }
 290
 291 const string &
 292 SimplePDF::PDF_HexString::hexstr( ) const
 293 {
 294         return my_hexstr;
 295 }
 296
 297 void
 298 SimplePDF::PDF_HexString::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 299 {
 300         os << "<" << my_hexstr << ">" ;
 301 }
 302
 303 /****************/
 304
 305 SimplePDF::PDF_Name::PDF_Name( const string & _name )
 306         : my_name( _name )
 307 { }
 308 SimplePDF::PDF_Name::~PDF_Name( )
 309 { }
 310
 311 const string &
 312 SimplePDF::PDF_Name::name( ) const
 313 {
 314         return my_name;
 315 }
 316
 317 void
 318 SimplePDF::PDF_Name::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 319 {
 320         os << "/" << my_name ;
 321 }
 322
 323 ostream & SimplePDF::operator << ( std::ostream & os, const PDF_Name & self )
 324 {
 325         return os << "/" << self.my_name ;
 326 }
 327
 328
 329 /****************/
 330
 331 SimplePDF::PDF_Vector::PDF_Vector( )
 332 { }
 333 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c )
 334 {
 335         vec.push_back( SimplePDF::newFloat( c ) );
 336 }
 337 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c1, PDF_Float::ValueType c2 )
 338 {
 339         vec.push_back( SimplePDF::newFloat( c1 ) );
 340         vec.push_back( SimplePDF::newFloat( c2 ) );
 341 }
 342 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType c1, PDF_Float::ValueType c2, PDF_Float::ValueType c3 )
 343 {
 344         vec.push_back( SimplePDF::newFloat( c1 ) );
 345         vec.push_back( SimplePDF::newFloat( c2 ) );
 346         vec.push_back( SimplePDF::newFloat( c3 ) );
 347 }
 348 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType x1, PDF_Float::ValueType y1,
 349                                                                                                                                          PDF_Float::ValueType x2, PDF_Float::ValueType y2 )
 350 {
 351         vec.push_back( SimplePDF::newFloat( x1 ) );
 352         vec.push_back( SimplePDF::newFloat( y1 ) );
 353         vec.push_back( SimplePDF::newFloat( x2 ) );
 354         vec.push_back( SimplePDF::newFloat( y2 ) );
 355 }
 356 SimplePDF::PDF_Vector::PDF_Vector( PDF_Float::ValueType a, PDF_Float::ValueType b,
 357                                                                                                                                          PDF_Float::ValueType c, PDF_Float::ValueType d,
 358                                                                                                                                          PDF_Float::ValueType e, PDF_Float::ValueType f )
 359 {
 360         vec.push_back( SimplePDF::newFloat( a ) );
 361         vec.push_back( SimplePDF::newFloat( b ) );
 362         vec.push_back( SimplePDF::newFloat( c ) );
 363         vec.push_back( SimplePDF::newFloat( d ) );
 364         vec.push_back( SimplePDF::newFloat( e ) );
 365         vec.push_back( SimplePDF::newFloat( f ) );
 366 }
 367 SimplePDF::PDF_Vector::PDF_Vector( PDF_Int::ValueType x1, PDF_Int::ValueType y1,
 368                                                                                                                                          PDF_Int::ValueType x2, PDF_Int::ValueType y2 )
 369 {
 370         vec.push_back( SimplePDF::newInt( x1 ) );
 371         vec.push_back( SimplePDF::newInt( y1 ) );
 372         vec.push_back( SimplePDF::newInt( x2 ) );
 373         vec.push_back( SimplePDF::newInt( y2 ) );
 374 }
 375 SimplePDF::PDF_Vector::~PDF_Vector( )
 376 { }
 377
 378 void
 379 SimplePDF::PDF_Vector::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 380 {
 381         os << "[" ;
 382         for( VecType::const_iterator i( vec.begin( ) ); i != vec.end( ); ++i )
 383                 {
 384                         os << " " ;
 385                         (*i)->writeTo( os, xref, *i );
 386                 }
 387         os << " ]" ;
 388 }
 389
 390 RefCountPtr< PDF_Object >
 391 SimplePDF::PDF_Vector::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 392 {
 393         bool allSame( true );
 394         RefCountPtr< PDF_Vector > res( new PDF_Vector );
 395         res->vec.reserve( vec.size( ) );
 396         for( VecType::iterator i( vec.begin( ) ); i != vec.end( ); ++i )
 397                 {
 398                         RefCountPtr< PDF_Object > copy( ::deepCopy( *i, indirectObjectCounter, remap ) );
 399                         res->vec.push_back( copy );
 400                         if( allSame && copy != *i )
 401                                 {
 402                                         allSame = false;
 403                                 }
 404                 }
 405         if( allSame )
 406                 {
 407                         return self;
 408                 }
 409         return res;
 410 }
 411
 412 RefCountPtr< SimplePDF::PDF_Vector >
 413 SimplePDF::PDF_Vector::rectangleIntersection( const RefCountPtr< SimplePDF::PDF_Vector > & other ) const
 414 {
 415         if( vec.size( ) != 4 )
 416                 {
 417                         throw "Internal error: PDF_Vector::rectangleIntersection: self size is not 4.";
 418                 }
 419         if( other->vec.size( ) != 4 )
 420                 {
 421                         throw "Internal error: PDF_Vector::rectangleIntersection: self size is not 4.";
 422                 }
 423
 424         RefCountPtr< PDF_Vector > res( new PDF_Vector );
 425         res->vec.reserve( vec.size( ) );
 426
 427         typedef typeof vec VectorType;
 428         typedef VectorType::const_iterator I;
 429         I src1 = vec.begin( );
 430         I src2 = other->vec.begin( );
 431         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( max( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 432         ++src1;
 433         ++src2;
 434         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( max( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 435         ++src1;
 436         ++src2;
 437         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( min( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 438         ++src1;
 439         ++src2;
 440         res->vec.push_back( RefCountPtr< PDF_Float >( new PDF_Float( min( SimplePDF::down_cast_follow< PDF_Float >( *src1 )->value( ), SimplePDF::down_cast_follow< PDF_Float >( *src2 )->value( ) ) ) ) );
 441
 442         return res;
 443 }
 444
 445
 446 /****************/
 447
 448 SimplePDF::PDF_Dictionary::PDF_Dictionary( )
 449 { }
 450 SimplePDF::PDF_Dictionary::PDF_Dictionary( const PDF_Dictionary & orig )
 451         : dic( orig.dic )
 452 { }
 453 SimplePDF::PDF_Dictionary::~PDF_Dictionary( )
 454 { }
 455
 456 void
 457 SimplePDF::PDF_Dictionary::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 458 {
 459         os << "<< " ;
 460         for( DicType::const_iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 461                 {
 462                         os << "/" << (i->first) << " " ;
 463                         (i->second)->writeTo( os, xref, i->second );
 464                         os << endl ;
 465                 }
 466         os << ">>" ;
 467 }
 468
 469 void
 470 SimplePDF::PDF_Dictionary::writeToWithLength( std::ostream & os, SimplePDF::PDF_xref * xref, size_t len ) const
 471 {
 472         os << "<< " ;
 473         os << "/Length " << len << endl ;
 474         for( DicType::const_iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 475                 {
 476                         os << "/" << (i->first) << " " ;
 477                         (i->second)->writeTo( os, xref, i->second );
 478                         os << endl ;
 479                 }
 480         os << ">>" ;
 481 }
 482
 483 PDF_Int::ValueType
 484 SimplePDF::PDF_Dictionary::getLength( ) const
 485 {
 486         DicType::const_iterator i( dic.find( string( "Length" ) ) );
 487         if( i == dic.end( ) )
 488                 {
 489                         throw( "Dictionary[Length]: /Length field missing" );
 490                 }
 491         RefCountPtr< const PDF_Int > theInt = SimplePDF::down_cast_follow< const PDF_Int >( i->second );
 492         if( theInt == NullPtr< const PDF_Int >( ) )
 493                 {
 494                         throw( "Dictionary[Length]: /Length is not a PDF_Int" );
 495                 }
 496         return theInt->value( );
 497 }
 498
 499 PDF_Int::ValueType
 500 SimplePDF::PDF_Dictionary::getCount( ) const
 501 {
 502         DicType::const_iterator i( dic.find( string( "Count" ) ) );
 503         if( i == dic.end( ) )
 504                 {
 505                         throw( "Dictionary[Count]: /Count field missing" );
 506                 }
 507         RefCountPtr< const PDF_Int > theInt = SimplePDF::down_cast_follow< const PDF_Int >( i->second );
 508         if( theInt == NullPtr< const PDF_Int >( ) )
 509                 {
 510                         throw( "Dictionary[Count]: /Count is not a PDF_Int" );
 511                 }
 512         return theInt->value( );
 513 }
 514
 515 bool
 516 SimplePDF::PDF_Dictionary::isPages( ) const
 517 {
 518         DicType::const_iterator i( dic.find( string( "Type" ) ) );
 519         if( i == dic.end( ) )
 520                 {
 521                         throw( "PDF_Dictionary::isPages: /Type field missing" );
 522                 }
 523         const PDF_Name * theType( dynamic_cast< const PDF_Name * >( i->second.getPtr( ) ) );
 524         if( theType == 0 )
 525                 {
 526                         throw( "PDF_Dictionary::isPages: /Type is not a PDF_Name" );
 527                 }
 528         return theType->name( ) == "Pages";
 529 }
 530
 531 RefCountPtr< SimplePDF::PDF_Object >
 532 SimplePDF::PDF_Dictionary::getInheritable( const char * name ) const
 533 {
 534         {
 535                 DicType::const_iterator i( dic.find( string( name ) ) );
 536                 if( i != dic.end( ) )
 537                         {
 538                                 return i->second;
 539                         }
 540         }
 541         {
 542                 DicType::const_iterator i( dic.find( string( "Parent" ) ) );
 543                 if( i != dic.end( ) )
 544                         {
 545                                 return SimplePDF::down_cast_follow< SimplePDF::PDF_Dictionary >( i->second )->getInheritable( name );
 546                         }
 547         }
 548         return RefCountPtr< SimplePDF::PDF_Object >( NullPtr< SimplePDF::PDF_Object >( ) );
 549 }
 550
 551
 552 RefCountPtr< PDF_Object > &
 553 SimplePDF::PDF_Dictionary::operator [] ( const char * key )
 554 {
 555         DicType::iterator i( dic.find( key ) );
 556         if( i == dic.end( ) )
 557                 {
 558                         return ((dic.insert(DicType::value_type( key, RefCountPtr< PDF_Object >( new PDF_Null( ) ) ))).first)->second;
 559                 }
 560         return i->second;
 561 }
 562
 563 bool
 564 SimplePDF::PDF_Dictionary::hasKey( const char * key ) const
 565 {
 566         return dic.find( key ) != dic.end( );
 567 }
 568
 569 RefCountPtr< PDF_Object >
 570 SimplePDF::PDF_Dictionary::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 571 {
 572         bool allSame( true );
 573         RefCountPtr< PDF_Dictionary > res( new PDF_Dictionary );
 574         for( DicType::iterator i( dic.begin( ) ); i != dic.end( ); ++i )
 575                 {
 576                         RefCountPtr< PDF_Object > copy( ::deepCopy( i->second, indirectObjectCounter, remap ) );
 577                         res->dic[ i->first ] = copy;
 578                         if( allSame && copy != i->second )
 579                                 {
 580                                         allSame = false;
 581                                 }
 582                 }
 583         if( allSame )
 584                 {
 585                         return self;
 586                 }
 587         return res;
 588 }
 589
 590 /****************/
 591
 592 SimplePDF::PDF_Stream::PDF_Stream( )
 593 { }
 594 SimplePDF::PDF_Stream::PDF_Stream( const PDF_Dictionary & dic )
 595         : PDF_Dictionary( dic )
 596 { }
 597 SimplePDF::PDF_Stream::~PDF_Stream( )
 598 { }
 599
 600 void
 601 SimplePDF::PDF_Stream::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 602 {
 603         throw "PDF_Stream::writeTo called";
 604 }
 605
 606 RefCountPtr< PDF_Object >
 607 SimplePDF::PDF_Stream::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 608 {
 609         throw "PDF_Stream::deepCopy must not be called. (However PDF_Stream_in::deepCopy may be called.)";
 610 }
 611
 612 PDF_Int::ValueType
 613 SimplePDF::PDF_Stream::getPredictor( ) const
 614 {
 615         PDF_Int::ValueType predictor = 1;
 616         DicType::const_iterator i = dic.find( "Predictor" );
 617         if( i != dic.end( ) )
 618                 {
 619                         RefCountPtr< PDF_Int > predictorIntObj( i->second.down_cast< PDF_Int >( ) );
 620                         if( predictorIntObj == NullPtr< PDF_Int >( ) )
 621                                 {
 622                                         throw( "The Predictor entry was not an integer (nor null) in the stream dictionary" );
 623                                 }
 624                         predictor = predictorIntObj->value( );
 625                 }
 626         return predictor;
 627 }
 628
 629 /****************/
 630
 631 SimplePDF::PDF_Stream_out::PDF_Stream_out( )
 632         : invertFilterOnWrite( true )
 633 {
 634         data << std::setiosflags( std::ios_base::fixed ) ;
 635 }
 636 SimplePDF::PDF_Stream_out::~PDF_Stream_out( )
 637 { }
 638
 639 void
 640 SimplePDF::PDF_Stream_out::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 641 {
 642         RefCountPtr< PDF_Object > filterEntry = RefCountPtr< PDF_Object >( new PDF_Null( ) );
 643         typedef typeof dic DicType;
 644         DicType::const_iterator i = dic.find( "Filter" );
 645         if( i == dic.end( ) || ! invertFilterOnWrite )
 646                 {
 647                         goto writeStream_NoFilter;
 648                 }
 649         else
 650                 {
 651                         filterEntry = i->second;
 652                 }
 653         if( filterEntry.down_cast< PDF_Null >( ) != NullPtr< PDF_Null >( ) )
 654                 {
 655                         goto writeStream_NoFilter;
 656                 }
 657
 658         {
 659                 RefCountPtr< PDF_Name > filterNameObj( filterEntry.down_cast< PDF_Name >( ) );
 660                 if( filterNameObj == NullPtr< PDF_Name >( ) )
 661                         {
 662                                 throw( "The Filter entry was not a name (nor null) in the stream dictionary." );
 663                         }
 664                 const string & filter( filterNameObj->name( ) );
 665
 666                 std::ostringstream stream;
 667                 if( filter == "FlateDecode" )
 668                         {
 669                                 writeStream_FlateDecode( stream );
 670                         }
 671                 else
 672                         {
 673                                 throw( "The Filter entry was not recognized: " + filter );
 674                         }
 675
 676                 {
 677                         const string & dataStr( stream.str( ) );
 678                         PDF_Dictionary::writeToWithLength( os, xref, dataStr.size( ) );
 679                         os << endl << "stream" << endl ;
 680                         os << dataStr << endl ;
 681                         os << "endstream " ;
 682                 }
 683         }
 684         return;
 685
 686  writeStream_NoFilter:
 687         {
 688                 const string & dataStr( data.str( ) );
 689                 PDF_Dictionary::writeToWithLength( os, xref, dataStr.size( ) );
 690                 os << endl << "stream" << endl ;
 691                 os << dataStr << endl ;
 692                 os << "endstream " ;
 693         }
 694 }
 695
 696 class Auto_zlib_deflateEnd
 697 {
 698         z_stream * strm_;
 699 public:
 700         Auto_zlib_deflateEnd( z_stream * strm )
 701                 : strm_( strm )
 702         { }
 703         ~Auto_zlib_deflateEnd( )
 704         {
 705                 deflateEnd( strm_ );
 706         }
 707 };
 708
 709 void
 710 SimplePDF::PDF_Stream_out::writeStream_FlateDecode( std::ostream & stream ) const
 711 {
 712         if( getPredictor( ) != 1 )
 713                 {
 714                         throw( "The only supported Predictor for FlateDecode compression is 1." );
 715                 }
 716
 717         const size_t BUFSIZE( 16384 );
 718         RefCountPtr< char > outBuf( new char[ BUFSIZE ] );
 719
 720         /* The following code follows the example in the zlib documentation rather closely. */
 721
 722         int ret, flush;
 723         size_t have;
 724         z_stream strm;
 725         Auto_zlib_deflateEnd autoDeflateEnd( & strm ); // Deallocate strm when we are done.
 726         unsigned char in[ BUFSIZE ];
 727         unsigned char out[ BUFSIZE ];
 728
 729         const int LEVEL = Z_DEFAULT_COMPRESSION;
 730         /* Alternative compression levels: */
 731         // Z_BEST_SPEED
 732         // Z_BEST_COMPRESSION
 733         // Z_DEFAULT_COMPRESSION
 734
 735         /* allocate deflate state */
 736         strm.zalloc = Z_NULL;
 737         strm.zfree = Z_NULL;
 738         strm.opaque = Z_NULL;
 739         ret = deflateInit( & strm, LEVEL );
 740         if( ret != Z_OK )
 741                 {
 742                         throw( std::string( "zlib call failed: " ) + zError( ret ) );
 743                 }
 744
 745         istringstream source( data.str( ) );
 746
 747         do
 748                 {
 749                         source.read( reinterpret_cast< char * >( in ), BUFSIZE );
 750                         strm.avail_in = source.gcount( );
 751                         if( ! source.good( ) && ! source.eof( ) )
 752                                 {
 753                                         throw( "Failed to read from data stream being FlateDecode compressed." );
 754                                 }
 755                         flush = source.eof( ) ? Z_FINISH : Z_NO_FLUSH;
 756                         strm.next_in = in;
 757
 758                         /* run deflate() on input until output buffer not full, finish
 759                                  compression if all of source has been read in */
 760         do
 761                                         {
 762             strm.avail_out = BUFSIZE;
 763             strm.next_out = out;
 764             ret = deflate( & strm, flush );    /* no bad return value */
 765                                                 CHECK( if( ret == Z_STREAM_ERROR )
 766                                                                                  {
 767                                                                                          throw( std::string( "zlib deflate call failed with Z_STREAM_ERROR: " ) + zError( ret ) );
 768                                                                                  }
 769                                                                          );
 770
 771                                                         have = BUFSIZE - strm.avail_out;
 772                                                         stream.write( reinterpret_cast< const char * >( out ), have ); /* It could be a good idea to check if this operation was successful... */
 773         }
 774                                 while( strm.avail_out == 0 );
 775                                 CHECK( if( strm.avail_in != 0 )
 776                                                                  {
 777                                                                          throw( std::string( "FlateDecode compression failed to consume all input." ) );
 778                                                                  }
 779                                                          );
 780
 781         /* done when last data in file processed */
 782     }
 783         while( flush != Z_FINISH );
 784         CHECK( if( ret != Z_STREAM_END )
 785                                          {
 786                                                  throw( std::string( "FlateDecode compression failed to complete zlib stream." ) );
 787                                          }
 788                                  );
 789 }
 790
 791 /****************/
 792
 793 SimplePDF::PDF_Stream_in::PDF_Stream_in( PDF_Dictionary * dic, istream * _is, streamoff _dataStart )
 794         : PDF_Stream( *dic ), is( _is ), dataStart( _dataStart )
 795 { }
 796 SimplePDF::PDF_Stream_in::PDF_Stream_in( istream * _is, streamoff _dataStart )
 797         : is( _is ), dataStart( _dataStart )
 798 { }
 799 SimplePDF::PDF_Stream_in::~PDF_Stream_in( )
 800 { }
 801
 802 void
 803 SimplePDF::PDF_Stream_in::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 804 {
 805         size_t length( PDF_Dictionary::getLength( ) );
 806         PDF_Dictionary::writeTo( os, xref, self );
 807         os << endl << "stream" << endl ;
 808         RefCountPtr< char > buf( new char[ length ] );
 809         is->seekg( dataStart, ios::beg );
 810         is->read( buf.getPtr( ), length );
 811         os.write( buf.getPtr( ), length );
 812         os << endl << "endstream " ;
 813 }
 814 void
 815 SimplePDF::PDF_Stream_in::writeDataTo( std::ostream & os ) const
 816 {
 817         size_t length( PDF_Dictionary::getLength( ) );
 818         RefCountPtr< char > buf( new char[ length ] );
 819         is->seekg( dataStart, ios::beg );
 820         is->read( buf.getPtr( ), length );
 821         os.write( buf.getPtr( ), length );
 822 }
 823 void
 824 SimplePDF::PDF_Stream_in::writeDataDefilteredTo( std::ostream & os ) const
 825 {
 826         if( dic.find( "Filter" ) == dic.end( ) )
 827                 {
 828                         writeDataTo( os );
 829                         return;
 830                 }
 831
 832         RefCountPtr< PDF_Object > filterEntry = RefCountPtr< PDF_Object >( new PDF_Null( ) );
 833         typedef typeof dic DicType;
 834         DicType::const_iterator i = dic.find( "Filter" );
 835         if( i != dic.end( ) )
 836                 {
 837                         filterEntry = i->second;
 838                 }
 839         if( filterEntry.down_cast< PDF_Null >( ) != NullPtr< PDF_Null >( ) )
 840                 {
 841                         writeDataTo( os );
 842                         return;
 843                 }
 844
 845         RefCountPtr< PDF_Name > filterNameObj( filterEntry.down_cast< PDF_Name >( ) );
 846         if( filterNameObj == NullPtr< PDF_Name >( ) )
 847                 {
 848                         throw( "The Filter entry was not a name (nor null) in the stream dictionary" );
 849                 }
 850         const string & filter( filterNameObj->name( ) );
 851
 852         if( filter == "FlateDecode" )
 853                 {
 854                         if( getPredictor( ) != 1 )
 855                                 {
 856                                         throw( "The only supported Predictor for FlateDecode decompression is 1." );
 857                                 }
 858
 859                         size_t inBufSize( PDF_Dictionary::getLength( ) );
 860                         RefCountPtr< char > inBuf( new char[ inBufSize ] );
 861                         is->seekg( dataStart, ios::beg );
 862                         is->read( inBuf.getPtr( ), inBufSize );
 863
 864                         const size_t BUFSIZE( 1024 );
 865                         RefCountPtr< char > outBuf( new char[ BUFSIZE ] );
 866
 867                         z_stream zs;
 868                         zs.next_in = reinterpret_cast< Bytef * >( inBuf.getPtr( ) );
 869                         zs.avail_in = inBufSize;
 870                         zs.next_out = reinterpret_cast< Bytef * >( outBuf.getPtr( ) );
 871                         zs.avail_out = BUFSIZE;
 872                         zs.zalloc = Z_NULL;
 873                         zs.zfree = Z_NULL;
 874                         switch( inflateInit( & zs ) )
 875                                 {
 876                                 case    Z_OK:
 877                                         break;
 878                                 default:
 879                                         throw( "inflateInit failed" );
 880                                 }
 881
 882                         {
 883                                 int status;
 884                                 while( ( status = inflate( & zs, Z_NO_FLUSH ) ) == Z_OK )
 885                                         {
 886                                                 os.write( outBuf.getPtr( ), BUFSIZE - zs.avail_out );
 887                                                 zs.next_out = reinterpret_cast< Bytef * >( outBuf.getPtr( ) );
 888                                                 zs.avail_out = BUFSIZE;
 889                                         }
 890                                 switch( status )
 891                                         {
 892                                         case Z_STREAM_END:
 893                                                 os.write( outBuf.getPtr( ), BUFSIZE - zs.avail_out );
 894                                                 break;
 895                                         default:
 896                                                 throw( "The inflate cycle did not finish with Z_STREAM_END" );
 897                                         }
 898                         }
 899
 900                         switch( inflateEnd( & zs ) )
 901                                 {
 902                                 case    Z_OK:
 903                                         break;
 904                                 default:
 905                                         throw( "inflateEnd failed" );
 906                                 }
 907                 }
 908         else
 909                 {
 910                         throw( "The filter " + filter + " is not yet supported" );
 911                 }
 912 }
 913
 914 RefCountPtr< PDF_Object >
 915 SimplePDF::PDF_Stream_in::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 916 {
 917         RefCountPtr< PDF_Object > dicCopy( PDF_Dictionary::deepCopy( self, indirectObjectCounter, remap ) );
 918         if( dicCopy.getPtr( ) == this )
 919                 {
 920                         return self;
 921                 }
 922         /* By increasing the count by 1, we ensure that the memory is not destroyed when this function exits.
 923          * We use that this object is newly created, so there are no other references to it.
 924          */
 925         if( *dicCopy.getCounterPtr( ) != 1 )
 926                 {
 927                         throw "I expected to own the only reference to the new PDF_Dictionary";
 928                 }
 929         ++(*dicCopy.getCounterPtr( ));
 930         return RefCountPtr< PDF_Stream_in >( new PDF_Stream_in( reinterpret_cast< PDF_Dictionary * >( dicCopy.getPtr( ) ), is, dataStart ) );
 931 }
 932 /****************/
 933
 934 SimplePDF::PDF_Indirect::PDF_Indirect( size_t _i, size_t _v )
 935         : i( _i ), v( _v )
 936 { }
 937 SimplePDF::PDF_Indirect::~PDF_Indirect( )
 938 { }
 939 void
 940 SimplePDF::PDF_Indirect_in::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 941 {
 942         throw "Internal error: PDF_Indirect_in::writeTo: This object is only good for reading, not for writing!";
 943         //      os << i << " " << v << " R" ;
 944 }
 945 bool SimplePDF::operator < ( const PDF_Indirect & o1, const PDF_Indirect & o2 )
 946 {
 947         if( o1.i < o2.i )
 948                 {
 949                         return true;
 950                 }
 951         if( o1.i > o2.i )
 952                 {
 953                         return false;
 954                 }
 955         if( o1.v < o2.v )
 956                 {
 957                         return true;
 958                 }
 959         return false;
 960 }
 961 RefCountPtr< PDF_Object >
 962 SimplePDF::PDF_Indirect::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
 963 {
 964         throw "PDF_Indirect::deepCopy must not be called.       (However PDF_Indirect_in::deepCopy may be called.)";
 965 }
 966 /****************/
 967
 968 SimplePDF::PDF_Indirect_out::PDF_Indirect_out( RefCountPtr<PDF_Object> _obj, size_t _i, size_t _v )
 969         : PDF_Indirect( _i, _v ), inUse( true ), obj( _obj )
 970 { }
 971 SimplePDF::PDF_Indirect_out::~PDF_Indirect_out( )
 972 { }
 973 void
 974 SimplePDF::PDF_Indirect_out::writeTo( std::ostream & os, SimplePDF::PDF_xref * xref, const RefCountPtr< const PDF_Object > & self ) const
 975 {
 976         xref->enqueue( self.down_cast< const PDF_Indirect_out >( ) );  /* This shall not fail! */
 977         os << xref->local( i ) << " " << v << " R" ;  /* We must not call xref->local before xref->enqueue ! */
 978 }
 979 void
 980 SimplePDF::PDF_Indirect_out::writeObject( std::ostream & os, SimplePDF::PDF_xref * xref ) const
 981 {
 982         if( inUse )
 983                 {
 984                         os << xref->local( i ) << " " << v << " obj" << endl ;
 985                         obj->writeTo( os, xref, obj );
 986                         os << endl << "endobj" << endl ;
 987                 }
 988 }
 989
 990 /****************/
 991
 992 SimplePDF::PDF_Indirect_in::PDF_Indirect_in( size_t _i, size_t _v )
 993         : PDF_Indirect( _i, _v ), PDFin( 0 )
 994 { }
 995 SimplePDF::PDF_Indirect_in::~PDF_Indirect_in( )
 996 { }
 997 RefCountPtr< PDF_Object >
 998 SimplePDF::PDF_Indirect_in::deref( )
 999 {
1000         if( PDFin == 0 )
1001                 {
1002                         throw( "PDF_Indirect_in::deref: PDFin is not assigned" );
1003                 }
1004         return PDFin->readObjectNumbered( i, v );
1005 }
1006 RefCountPtr< PDF_Object >
1007 SimplePDF::PDF_Indirect_in::deepCopy( RefCountPtr< PDF_Object > self, size_t * indirectObjectCounter, IndirectRemapType * remap )
1008 {
1009         {
1010                 IndirectRemapType::iterator i( remap->find( *this ) );
1011                 if( i != remap->end( ) )
1012                         {
1013                                 return i->second;
1014                         }
1015         }
1016         return remap->insert( IndirectRemapType::value_type( *this, SimplePDF::indirect( ::deepCopy( deref( ), indirectObjectCounter, remap ),
1017                                                                                                                                                                                                                                                                                                                                          indirectObjectCounter ) ) ).first->second;
1018 }
1019
1020 /**************/
1021
1022 SimplePDF::PDF_xref::PDF_xref( )
1023         : size_( 0 )
1024 {
1025         /* The first position in the xref table is special. */
1026         localOrder_.push_back( 0 ); /* The first object shall appear in the xref table. */
1027         localNumbers_.push_back( 0 ); /* It has number 0. */
1028         byteOffsets_.push_back( 0 ); /* This is interpreted as "not in use" */
1029         generations_.push_back( 65535 );
1030 }
1031
1032 void
1033 SimplePDF::PDF_xref::enqueue( const RefCountPtr< const::PDF_Indirect_out > & obj )
1034 {
1035         /* Grow big enough */
1036         while( byteOffsets_.size( ) <= obj->i )
1037                 {
1038                         localNumbers_.push_back( 0 );
1039                         byteOffsets_.push_back( 0 );
1040                         generations_.push_back( 0 );
1041                 }
1042
1043         if( byteOffsets_[ obj->i ] == 0 )
1044                 {
1045                         indirectQueue_.push_back( obj );
1046                         localNumbers_[ obj->i ] = localOrder_.size( );
1047                         byteOffsets_[ obj->i ] = 1; /* We will change this later, this just indicates that the object has been put in queue. */
1048                         localOrder_.push_back( obj->i );
1049                 }
1050 }
1051
1052 void
1053 SimplePDF::PDF_xref::writeRecursive( std::ostream & os )
1054 {
1055         std::streamoff os_start;
1056         {
1057                 std::streamoff tmp = static_cast< streamoff >( os.tellp( ) );
1058                 os.seekp( 0 );
1059                 os_start = static_cast< streamoff >( os.tellp( ) ); /* Will this always be some kind of zero value? */
1060                 os.seekp( tmp );
1061         }
1062         while( ! indirectQueue_.empty( ) )
1063                 {
1064                         RefCountPtr< const SimplePDF::PDF_Indirect_out > i_obj = indirectQueue_.front( );
1065                         indirectQueue_.pop_front( );
1066                         byteOffsets_[ i_obj->i ] = static_cast< streamoff >( os.tellp( ) ) - os_start;
1067                         generations_[ i_obj->i ] = i_obj->v;
1068                         i_obj->writeObject( os, this );
1069                 }
1070 }
1071
1072 size_t
1073 SimplePDF::PDF_xref::local( size_t i ) const
1074 {
1075         return localNumbers_[ i ];
1076 }
1077
1078 void
1079 SimplePDF::PDF_xref::writeTable( std::ostream & os ) const
1080 {
1081         if( size_ > 0 )
1082                 {
1083                         throw "Internal error: PDF_xref::writeTable: This table has already been written.";
1084                 }
1085         size_ = localOrder_.size( );
1086
1087         os << setfill( '0' ) ;
1088         os << "xref" << endl
1089                  << 0 << " " << size_ << endl ;
1090         typedef typeof localOrder_ ListType;
1091         for( ListType::const_iterator i = localOrder_.begin( ); i != localOrder_.end( ); ++i )
1092                 {
1093                         size_t o = byteOffsets_[ *i ];
1094                         size_t v = generations_[ *i ];
1095                         os << setw( 10 ) << o << ' ' << setw( 5 ) << v << ' ' << ( ( o == 0 ) ? 'f' : 'n' ) << ' ' << static_cast< char >( 10 ) ;
1096                 }
1097 }
1098
1099 size_t
1100 SimplePDF::PDF_xref::size( ) const
1101 {
1102         if( size_ == 0 )
1103                 {
1104                         throw "Internal error: PDF_xref::size: The size of the table is not determined yet.  Call writeTable first.";
1105                 }
1106         return size_;
1107 }
1108
1109
1110 /**************/
1111
1112 RefCountPtr< PDF_Indirect_out >
1113 SimplePDF::indirect( RefCountPtr< PDF_Object > obj, size_t * i, size_t v )
1114 {
1115         return RefCountPtr< PDF_Indirect_out >( new PDF_Indirect_out( obj, (*i)++, v ) );
1116 }
1117
1118 RefCountPtr< PDF_Object >
1119 SimplePDF::deepCopy( RefCountPtr< PDF_Object > obj, size_t * indirectObjectCounter, IndirectRemapType * remap )
1120 {
1121         return obj->deepCopy( obj, indirectObjectCounter, remap );
1122 }