strigi-analyzer/ps/dscparse_adapter.cpp

   1 /**
   2  * Copyright (C) 2001 the KGhostView authors. See file AUTHORS.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "dscparse_adapter.h"
  20
  21 using namespace std;
  22
  23 /*-- KDSCBBOX implementation -----------------------------------------------*/
  24
  25 KDSCBBOX::KDSCBBOX() :
  26     _llx( 0 ), _lly( 0 ),
  27     _urx( 0 ), _ury( 0 )
  28 {}
  29
  30 KDSCBBOX::KDSCBBOX( const KDSCBBOX& b ) :
  31     _llx( b._llx ), _lly( b._lly ),
  32     _urx( b._urx ), _ury( b._ury )
  33 {}
  34
  35 KDSCBBOX::KDSCBBOX( int llx, int lly, int urx, int ury ) :
  36     _llx( llx ), _lly( lly ),
  37     _urx( urx ), _ury( ury )
  38 {}
  39
  40 KDSCBBOX::KDSCBBOX( const CDSCBBOX& bbox ) :
  41     _llx( bbox.llx ), _lly( bbox.lly ),
  42     _urx( bbox.urx ), _ury( bbox.ury )
  43 {}
  44
  45 KDSCBBOX& KDSCBBOX::operator = ( const KDSCBBOX& b )
  46 {
  47     _llx = b._llx; _lly = b._lly; _urx = b._urx; _ury = b._ury;
  48     return *this;
  49 }
  50
  51 bool KDSCBBOX::operator == ( const KDSCBBOX& b )
  52 {
  53     return ( _llx == b._llx && _lly == b._lly
  54           && _urx == b._urx && _ury == b._ury );
  55 }
  56
  57 bool KDSCBBOX::operator != ( const KDSCBBOX& b )
  58 {
  59     return !( *this == b );
  60 }
  61
  62 int KDSCBBOX::llx() const { return _llx; }
  63 int KDSCBBOX::lly() const { return _lly; }
  64 int KDSCBBOX::urx() const { return _urx; }
  65 int KDSCBBOX::ury() const { return _ury; }
  66
  67 int KDSCBBOX::width()  const { return _urx - _llx; }
  68 int KDSCBBOX::height() const { return _ury - _lly; }
  69
  70 QSize KDSCBBOX::size() const { return QSize( width(), height() ); }
  71
  72 ostream& operator << ( ostream& os, const KDSCBBOX& source )
  73 {
  74     os << "{ llx: "<< source.llx() << ", lly: " << source.lly()
  75        <<  " urx: "<< source.urx() << ", ury: " << source.ury() << " }";
  76     return os;
  77 }
  78
  79 /*-- KDSCError implementation ----------------------------------------------*/
  80
  81 KDSCError::KDSCError( Type type, Severity severity, const QByteArray& line,
  82                       unsigned int lineNumber ) :
  83     _type( type ),
  84     _severity( severity ),
  85     _line( line ),
  86     _lineNumber( lineNumber )
  87 {}
  88
  89 KDSCError::Type KDSCError::type() const
  90 {
  91     return _type;
  92 }
  93
  94 KDSCError::Severity KDSCError::severity() const
  95 {
  96     return _severity;
  97 }
  98
  99 QByteArray KDSCError::line() const
 100 {
 101     return _line;
 102 }
 103
 104 unsigned int KDSCError::lineNumber() const
 105 {
 106     return _lineNumber;
 107 }
 108
 109 /*-- KDSCOkErrorHandler implementation -------------------------------------*/
 110
 111 KDSCErrorHandler::Response KDSCOkErrorHandler::error( const KDSCError& err )
 112 {
 113     cout << "KDSC: error in line " << err.lineNumber() << endl;
 114     //cout << err.line() << endl;
 115     return Ok;
 116 }
 117
 118 /*-- KDSC implementation ---------------------------------------------------*/
 119
 120 KDSC::KDSC() :
 121     _errorHandler( 0 ),
 122     _commentHandler( 0 )
 123 {
 124     _cdsc = dsc_init( this );
 125     Q_ASSERT( _cdsc != 0 );
 126     _scanHandler = new KDSCScanHandler( _cdsc );
 127 }
 128
 129 KDSC::~KDSC()
 130 {
 131     dsc_free( _cdsc );
 132     delete _scanHandler;
 133 }
 134
 135 QString KDSC::dsc_version() const
 136 {
 137     return QString( _cdsc->dsc_version );
 138 }
 139
 140 bool KDSC::dsc() const
 141 {
 142     return ( _cdsc->dsc == TRUE );
 143 }
 144
 145 bool KDSC::ctrld() const
 146 {
 147     return ( _cdsc->ctrld == TRUE );
 148 }
 149
 150 bool KDSC::pjl() const
 151 {
 152     return ( _cdsc->pjl == TRUE );
 153 }
 154
 155 bool KDSC::epsf() const
 156 {
 157     return ( _cdsc->epsf == TRUE );
 158 }
 159
 160 bool KDSC::pdf() const
 161 {
 162     return ( _cdsc->pdf == TRUE );
 163 }
 164
 165 unsigned int KDSC::preview() const
 166 {
 167     return _cdsc->preview;
 168 }
 169
 170 unsigned int KDSC::language_level() const
 171 {
 172     return _cdsc->language_level;
 173 }
 174
 175 unsigned int KDSC::document_data() const
 176 {
 177     return _cdsc->document_data;
 178 }
 179
 180 unsigned long KDSC::begincomments() const
 181 {
 182     return _cdsc->begincomments;
 183 }
 184
 185 unsigned long KDSC::endcomments() const
 186 {
 187     return _cdsc->endcomments;
 188 }
 189
 190 unsigned long KDSC::beginpreview() const
 191 {
 192     return _cdsc->beginpreview;
 193 }
 194
 195 unsigned long KDSC::endpreview() const
 196 {
 197     return _cdsc->endpreview;
 198 }
 199
 200 unsigned long KDSC::begindefaults() const
 201 {
 202     return _cdsc->begindefaults;
 203 }
 204
 205 unsigned long KDSC::enddefaults() const
 206 {
 207     return _cdsc->enddefaults;
 208 }
 209
 210 unsigned long KDSC::beginprolog() const
 211 {
 212     return _cdsc->beginprolog;
 213 }
 214
 215 unsigned long KDSC::endprolog() const
 216 {
 217     return _cdsc->endprolog;
 218 }
 219
 220 unsigned long KDSC::beginsetup() const
 221 {
 222     return _cdsc->beginsetup;
 223 }
 224
 225 unsigned long KDSC::endsetup() const
 226 {
 227     return _cdsc->endsetup;
 228 }
 229
 230 unsigned long KDSC::begintrailer() const
 231 {
 232     return _cdsc->begintrailer;
 233 }
 234
 235 unsigned long KDSC::endtrailer() const
 236 {
 237     return _cdsc->endtrailer;
 238 }
 239
 240 CDSCPAGE* KDSC::page() const
 241 {
 242     return _cdsc->page;
 243 }
 244
 245 unsigned int KDSC::page_count() const
 246 {
 247     return _cdsc->page_count;
 248 }
 249
 250 unsigned int KDSC::page_pages() const
 251 {
 252     return _cdsc->page_pages;
 253 }
 254
 255 unsigned int KDSC::page_order() const
 256 {
 257     return _cdsc->page_order;
 258 }
 259
 260 unsigned int KDSC::page_orientation() const
 261 {
 262     return _cdsc->page_orientation;
 263 }
 264
 265 CDSCCTM* KDSC::viewing_orientation() const
 266 {
 267     return _cdsc->viewing_orientation;
 268 }
 269
 270 unsigned int KDSC::media_count() const
 271 {
 272     return _cdsc->media_count;
 273 }
 274
 275 CDSCMEDIA** KDSC::media() const
 276 {
 277     return _cdsc->media;
 278 }
 279
 280 const CDSCMEDIA* KDSC::page_media() const
 281 {
 282     return _cdsc->page_media;
 283 }
 284
 285 auto_ptr<KDSCBBOX> KDSC::bbox() const
 286 {
 287     if( _cdsc->bbox == 0 )
 288         return auto_ptr<KDSCBBOX>( 0 );
 289     else
 290         return auto_ptr<KDSCBBOX>( new KDSCBBOX( *_cdsc->bbox ) );
 291 }
 292
 293 auto_ptr<KDSCBBOX> KDSC::page_bbox() const
 294 {
 295     if( _cdsc->page_bbox == 0 )
 296         return auto_ptr<KDSCBBOX>( 0 );
 297     else
 298         return auto_ptr<KDSCBBOX>( new KDSCBBOX( *_cdsc->page_bbox ) );
 299 }
 300
 301 QString KDSC::dsc_title() const
 302 {
 303     return QString( _cdsc->dsc_title );
 304 }
 305
 306 QString KDSC::dsc_creator() const
 307 {
 308     return QString( _cdsc->dsc_creator );
 309 }
 310
 311 QString KDSC::dsc_date() const
 312 {
 313     return QString( _cdsc->dsc_date );
 314 }
 315
 316 QString KDSC::dsc_for() const
 317 {
 318     return QString( _cdsc->dsc_for );
 319 }
 320
 321 bool KDSC::scanData( char* buffer, unsigned int count )
 322 {
 323     return _scanHandler->scanData( buffer, count );
 324 }
 325
 326 int KDSC::fixup()
 327 {
 328     return dsc_fixup( _cdsc );
 329 }
 330
 331 KDSCErrorHandler* KDSC::errorHandler() const
 332 {
 333     return _errorHandler;
 334 }
 335
 336 void KDSC::setErrorHandler( KDSCErrorHandler* errorHandler )
 337 {
 338     _errorHandler = errorHandler;
 339     if( errorHandler == 0 )
 340         dsc_set_error_function( _cdsc, 0 );
 341     else
 342         dsc_set_error_function( _cdsc, &errorFunction );
 343 }
 344
 345 KDSCCommentHandler* KDSC::commentHandler() const
 346 {
 347     return _commentHandler;
 348 }
 349
 350 void KDSC::setCommentHandler( KDSCCommentHandler* commentHandler )
 351 {
 352     if( _commentHandler != 0 && commentHandler == 0 )
 353     {
 354         delete _scanHandler;
 355         _scanHandler = new KDSCScanHandler( _cdsc );
 356     }
 357     else if( _commentHandler == 0 && commentHandler != 0 )
 358     {
 359         delete _scanHandler;
 360         _scanHandler = new KDSCScanHandlerByLine( _cdsc, commentHandler );
 361     }
 362     _commentHandler = commentHandler;
 363 }
 364
 365 bool KDSC::isStructured() const
 366 {
 367     return epsf() ? ( page_count() > 1 ) : ( page_count() > 0 );
 368 }
 369
 370 CDSC* KDSC::cdsc() const
 371 {
 372     return _cdsc;
 373 }
 374
 375 int KDSC::errorFunction( void* caller_data, CDSC* dsc,
 376         unsigned int explanation, const char* line, unsigned int line_len )
 377 {
 378     KDSCError error(
 379             static_cast< KDSCError::Type >( explanation ),
 380             static_cast< KDSCError::Severity >( dsc->severity[explanation] ),
 381             QByteArray( line, line_len + 1 ),
 382             dsc->line_count
 383     );
 384
 385     KDSC* kdsc = static_cast< KDSC* >( caller_data );
 386     Q_ASSERT( kdsc );
 387
 388     return kdsc->errorHandler()->error( error );
 389 }
 390
 391 bool KDSCScanHandlerByLine::scanData( char* buf, unsigned int count )
 392 {
 393     char* lineStart = buf;
 394     char* it = buf;
 395     while( it < buf + count )
 396     {
 397         if( *it++ == '\n' )
 398         {
 399             int retval = dsc_scan_data( _cdsc, lineStart, it - lineStart );
 400             if( retval < 0 )
 401                 return false;
 402             else if( retval > 0 )
 403             {
 404                 _commentHandler->comment(
 405                         static_cast<KDSCCommentHandler::Name>( retval ) );
 406             }
 407             lineStart = it;
 408         }
 409     }
 410
 411     if( it != lineStart )
 412     {
 413         // Scan the remaining part of the string.
 414         return ( dsc_scan_data( _cdsc, lineStart, it - lineStart ) < 0 );
 415     }
 416     else
 417         return true;
 418 }
 419
 420 // vim:sw=4:sts=4:ts=8:noet