Changeset 280


Ignore:
Timestamp:
Jan 3, 2010, 7:13:32 PM (11 years ago)
Author:
rbri
Message:

DJVU plugin: djvulibre updated to version 3.5.22

Location:
trunk/libdjvu
Files:
2 added
1 deleted
108 edited

Legend:

Unmodified
Added
Removed
  • trunk/libdjvu/Arrays.cpp

    r206 r280  
    5555//
    5656// $Id: Arrays.cpp,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/Arrays.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: Arrays.h,v 1.12 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: Arrays.h,v 1.13 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _ARRAYS_H_
     
    126126    Andrei Erofeev <eaf@geocities.com> -- Copy-on-demand implementation.
    127127    @version
    128     #$Id: Arrays.h,v 1.12 2007/03/25 20:48:29 leonb Exp $# */
     128    #$Id: Arrays.h,v 1.13 2007/05/19 03:07:33 leonb Exp $# */
    129129//@{
    130130
     
    185185// static functions which pointers are supposed to be passed to the
    186186// constructor.
    187 class ArrayRep : public _ArrayRep
     187class DJVUAPI ArrayRep : public _ArrayRep
    188188{
    189189public:
     
    305305    */
    306306   
    307 class ArrayBase : protected _ArrayBase
     307class DJVUAPI ArrayBase : protected _ArrayBase
    308308{
    309309protected:
  • trunk/libdjvu/BSByteStream.cpp

    r206 r280  
    5555//
    5656// $Id: BSByteStream.cpp,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/BSByteStream.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: BSByteStream.h,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: BSByteStream.h,v 1.10 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _BSBYTESTREAM_H
     
    145145    Simple Burrows-Wheeler general purpose compressor.
    146146    @version
    147     #$Id: BSByteStream.h,v 1.9 2007/03/25 20:48:29 leonb Exp $# */
     147    #$Id: BSByteStream.h,v 1.10 2007/05/19 03:07:33 leonb Exp $# */
    148148//@{
    149149
     
    199199    \Ref{IFFByteStream}.)
    200200*/
    201 class BSByteStream : public ByteStream
     201class DJVUAPI BSByteStream : public ByteStream
    202202{
    203203public:
  • trunk/libdjvu/BSEncodeByteStream.cpp

    r206 r280  
    5555//
    5656// $Id: BSEncodeByteStream.cpp,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/ByteStream.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: ByteStream.cpp,v 1.23 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: ByteStream.cpp,v 1.24 2007/07/14 01:21:56 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959// From: Leon Bottou, 1/31/2002
     
    7878#include "DjVuMessage.h"
    7979#include <fcntl.h>
    80 #if defined(WIN32) || defined(__CYGWIN32__)
     80/* Lucide */
     81#if defined(WIN32) || defined(__CYGWIN32__) || defined(OS2)
    8182# include <io.h>
    8283#endif
     
    8889#endif
    8990
    90 #if defined(UNIX) || defined(OS2)
     91#ifdef UNIX
    9192# include <sys/types.h>
    9293# include <sys/stat.h>
     
    9697#  include <sys/mman.h>
    9798# endif
    98 #elif defined(macintosh)
    99 # include <unistd.h>
     99#endif
     100
     101#ifdef macintosh
     102# ifndef UNIX
     103#  include <unistd.h>
    100104_MSL_IMP_EXP_C int _dup(int);
    101105_MSL_IMP_EXP_C int _dup2(int,int);
     
    103107__inline int dup(int _a ) { return _dup(_a);}
    104108__inline int dup2(int _a, int _b ) { return _dup2(_a, _b);}
     109# endif
     110#endif
     111
     112#ifdef WIN32
     113# if !defined(__MINGW32__) && !defined(__CYGWIN32__)
     114#  define close _close
     115#  define fdopen _fdopen
     116#  define dup _dup
     117# endif
    105118#endif
    106119
  • trunk/libdjvu/ByteStream.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: ByteStream.h,v 1.15 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: ByteStream.h,v 1.16 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _BYTESTREAM_H
     
    100100
    101101    @version
    102     #$Id: ByteStream.h,v 1.15 2007/03/25 20:48:29 leonb Exp $# */
     102    #$Id: ByteStream.h,v 1.16 2007/05/19 03:07:33 leonb Exp $# */
    103103//@{
    104104
     
    129129    of instances of this class, as implied by the class semantic. 
    130130*/
    131 class ByteStream : public GPEnabled
     131class DJVUAPI ByteStream : public GPEnabled
    132132{
    133133public:
     
    374374    for derived classes that take a GP<ByteStream> as a creation argument,
    375375    and the backwards compatible bytestreams.  */
    376 class ByteStream::Wrapper : public ByteStream
     376class DJVUAPI ByteStream::Wrapper : public ByteStream
    377377{
    378378protected:
  • trunk/libdjvu/DataPool.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DataPool.cpp,v 1.14 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DataPool.cpp,v 1.17 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    540540         block_end=block_start+abs(size);
    541541         if (size<0)
    542             if (block_start<start)
    543             {
    544                if (block_end>start && block_end<=start+length)
     542           {
     543             if (block_start<start)
    545544               {
    546                   list[pos]=-(start-block_start);
    547                   list.insert_after(pos, block_end-start);
    548                   ++pos;
    549                   block_start=start;
    550                } else if (block_end>start+length)
     545                 if (block_end>start && block_end<=start+length)
     546                   {
     547                     list[pos]=-(start-block_start);
     548                     list.insert_after(pos, block_end-start);
     549                     ++pos;
     550                     block_start=start;
     551                   } else if (block_end>start+length)
     552                   {
     553                     list[pos]=-(start-block_start);
     554                     list.insert_after(pos, length);
     555                     ++pos;
     556                     list.insert_after(pos, -(block_end-(start+length)));
     557                     ++pos;
     558                     block_start=start+length;
     559                   }
     560               } else if (block_start>=start && block_start<start+length)
    551561               {
    552                   list[pos]=-(start-block_start);
    553                   list.insert_after(pos, length);
    554                   ++pos;
    555                   list.insert_after(pos, -(block_end-(start+length)));
    556                   ++pos;
    557                   block_start=start+length;
     562                 if (block_end<=start+length) list[pos]=abs(size);
     563                 else
     564                   {
     565                     list[pos]=start+length-block_start;
     566                     list.insert_after(pos, -(block_end-(start+length)));
     567                     ++pos;
     568                     block_start=start+length;
     569                   }
    558570               }
    559             } else if (block_start>=start && block_start<start+length)
    560             {
    561                if (block_end<=start+length) list[pos]=abs(size);
    562                else
    563                {
    564                   list[pos]=start+length-block_start;
    565                   list.insert_after(pos, -(block_end-(start+length)));
    566                   ++pos;
    567                   block_start=start+length;
    568                }
    569             }
     571           }
    570572         block_start=block_end;
    571573         ++pos;
     
    583585         GPosition pos1=pos; ++pos1;
    584586         while(pos1)
    585          {
    586             if (list[pos]<0 && list[pos1]>0 ||
    587                 list[pos]>0 && list[pos1]<0)
     587           {
     588             if ( (list[pos]<0 && list[pos1]>0) ||
     589                  (list[pos]>0 && list[pos1]<0) )
    588590               break;
    589             list[pos]+=list[pos1];
    590             GPosition this_pos=pos1;
    591             ++pos1;
    592             list.del(this_pos);
    593          }
     591             list[pos]+=list[pos1];
     592             GPosition this_pos=pos1;
     593             ++pos1;
     594             list.del(this_pos);
     595           }
    594596         pos=pos1;
    595597      }
     
    616618      block_end=block_start+abs(size);
    617619      if (size>0)
    618          if (block_start<start)
    619          {
    620             if (block_end>=start && block_end<start+length)
    621                bytes+=block_end-start;
    622             else if (block_end>=start+length)
    623                bytes+=length;
    624          } else
    625          {
    626             if (block_end<=start+length)
    627                bytes+=block_end-block_start;
    628             else bytes+=start+length-block_start;
    629          }
     620        {
     621          if (block_start<start)
     622            {
     623              if (block_end>=start && block_end<start+length)
     624                bytes+=block_end-start;
     625              else if (block_end>=start+length)
     626                bytes+=length;
     627            }
     628          else
     629            {
     630              if (block_end<=start+length)
     631                bytes+=block_end-block_start;
     632              else bytes+=start+length-block_start;
     633            }
     634        }
    630635      block_start=block_end;
    631636   }
     
    649654   int block_start=0, block_end=0;
    650655   for(GPosition pos=list;pos && block_start<start+length;++pos)
    651    {
    652       int size=list[pos];
    653       block_end=block_start+abs(size);
    654       if (block_start<=start && block_end>start)
    655          if (size<0) return -1;
    656          else
    657             if (block_end>start+length) return length;
    658             else return block_end-start;
    659       block_start=block_end;
    660    }
     656     {
     657       int size=list[pos];
     658       block_end=block_start+abs(size);
     659       if (block_start<=start && block_end>start)
     660         {
     661           if (size<0)
     662             return -1;
     663           else if (block_end>start+length)
     664             return length;
     665           else
     666             return block_end-start;
     667         }
     668       block_start=block_end;
     669     }
    661670   return 0;
    662671}
     
    836845  clear_stream(true);
    837846  if (furl.is_local_file_url())
    838   {
    839     FCPools::get()->del_pool(furl, this);
    840   }
    841    
     847    if (this->get_count() > 1)
     848      FCPools::get()->del_pool(furl, this);
     849 
     850  GP<DataPool> pool = this->pool;
    842851  {
    843852         // Wait until the static_trigger_cb() exits
     
    847856      del_trigger(static_trigger_cb, this);
    848857  }
    849 
    850858  if (pool)
    851859  {
     
    985993   }
    986994   
    987    if (pool) return pool->get_size(start+dstart, dlength);
     995   GP<DataPool> pool = this->pool;
     996   if (pool)
     997     return pool->get_size(start+dstart, dlength);
    988998   else if (furl.is_local_file_url())
    989999   {
     
    11211131   if (! sz)
    11221132     return 0;
    1123    
     1133
     1134   GP<DataPool> pool = this->pool;
    11241135   if (pool)
    11251136     {
     
    11281139       int retval=0;
    11291140       if (length>0 && offset+sz>length)
    1130         sz=length-offset;
     1141        sz=length-offset;
    11311142       if (sz<0)
    1132         sz=0;
     1143        sz=0;
    11331144       for(;;)
    1134          {
    1135            // Ask the underlying (master) DataPool for data. Note, that
    1136            // master DataPool may throw the "DATA_POOL_REENTER" exception
    1137            // demanding all readers to restart. This happens when
    1138            // a DataPool in the chain of DataPools stops. All readers
    1139            // should return to the most upper level and then reenter the
    1140            // DataPools hierarchy. Some of them will be stopped by
    1141            // DataPool::Stop exception.
    1142            G_TRY
    1143              {
    1144                if(stop_flag||stop_blocked_flag&&!is_eof()&&!has_data(offset, sz))
    1145                  G_THROW( DataPool::Stop );
    1146                retval=pool->get_data(buffer, start+offset, sz, level+1);
    1147              }
    1148            G_CATCH(exc)
    1149              {
    1150                pool->clear_stream(true);
    1151                if ((exc.get_cause() != GUTF8String( ERR_MSG("DataPool.reenter") ) )
    1152                    || level)
    1153                  G_RETHROW;
    1154              } G_ENDCATCH;
    1155            pool->clear_stream(true);
    1156            return retval;
    1157          }
     1145         {
     1146           // Ask the underlying (master) DataPool for data. Note, that
     1147           // master DataPool may throw the "DATA_POOL_REENTER" exception
     1148           // demanding all readers to restart. This happens when
     1149           // a DataPool in the chain of DataPools stops. All readers
     1150           // should return to the most upper level and then reenter the
     1151           // DataPools hierarchy. Some of them will be stopped by
     1152           // DataPool::Stop exception.
     1153           G_TRY
     1154             {
     1155               if(stop_flag
     1156                  || (stop_blocked_flag && !is_eof() && !has_data(offset, sz)))
     1157                 G_THROW( DataPool::Stop );
     1158               retval=pool->get_data(buffer, start+offset, sz, level+1);
     1159             }
     1160           G_CATCH(exc)
     1161           {
     1162             pool->clear_stream(true);
     1163             if ((exc.get_cause() != GUTF8String(ERR_MSG("DataPool.reenter")))
     1164                 || level)
     1165               G_RETHROW;
     1166           } G_ENDCATCH;
     1167           pool->clear_stream(true);
     1168           return retval;
     1169         }
    11581170     }
    11591171   else if (furl.is_local_file_url())
     
    11621174       DEBUG_MAKE_INDENT(3);
    11631175       if (length>0 && offset+sz>length)
    1164         sz=length-offset;
     1176        sz=length-offset;
    11651177       if (sz<0)
    11661178         sz=0;
     
    13411353      // Others (which entered the master DataPool thru other slave DataPools)
    13421354      // will simply continue waiting for their data.
     1355   GP<DataPool> pool = this->pool;
    13431356   if (pool)
    13441357   {
     
    14321445  DEBUG_MSG("DataPool::check_triggers(): calling activated trigger callbacks.\n");
    14331446  DEBUG_MAKE_INDENT(3);
    1434  
     1447
    14351448  if (!pool && !furl.is_local_file_url())
    14361449    while(true)
    1437     {
    1438       GP<Trigger> trigger;
    1439      
    1440       // First find a candidate (trigger, which needs to be called)
    1441       // Don't remove it from the list yet. del_trigger() should
    1442       // be able to find it if necessary and disable.
    1443       {
    1444         GCriticalSectionLock list_lock(&triggers_lock);
    1445         for(GPosition pos=triggers_list;pos;++pos)
    1446         {
    1447           GP<Trigger> t=triggers_list[pos];
    1448           if (is_eof() || t->length>=0 &&
    1449             block_list->get_bytes(t->start, t->length)==t->length)
    1450           {
    1451             trigger=t;
    1452             break;
    1453           }
    1454         }
    1455       }
    1456      
    1457       if (trigger)
    1458       {
    1459                // Now check that the trigger is not disabled
    1460                // and lock the trigger->disabled lock for the duration
    1461                // of the trigger. This will block the del_trigger() and
    1462                // will postpone client's destruction (usually following
    1463                // the call to del_trigger())
    1464         {
    1465           GMonitorLock lock(&trigger->disabled);
    1466           if (!trigger->disabled)
    1467             call_callback(trigger->callback, trigger->cl_data);
    1468         }
    1469        
    1470                // Finally - remove the trigger from the list.
    1471         GCriticalSectionLock list_lock(&triggers_lock);
    1472         for(GPosition pos=triggers_list;pos;++pos)
    1473           if (triggers_list[pos]==trigger)
    1474           {
    1475             triggers_list.del(pos);
    1476             break;
    1477           }
    1478       } else break;
    1479     }
     1450      {
     1451        GP<Trigger> trigger;
     1452
     1453        // First find a candidate (trigger, which needs to be called)
     1454        // Don't remove it from the list yet. del_trigger() should
     1455        // be able to find it if necessary and disable.
     1456        {
     1457          GCriticalSectionLock list_lock(&triggers_lock);
     1458          for(GPosition pos=triggers_list;pos;++pos)
     1459            {
     1460              GP<Trigger> t=triggers_list[pos];
     1461              if (is_eof()
     1462                  || (t->length>=0 &&
     1463                      block_list->get_bytes(t->start, t->length)==t->length))
     1464                {
     1465                  trigger=t;
     1466                  break;
     1467                }
     1468            }
     1469        }
     1470
     1471        if (trigger)
     1472          {
     1473            // Now check that the trigger is not disabled
     1474            // and lock the trigger->disabled lock for the duration
     1475            // of the trigger. This will block the del_trigger() and
     1476            // will postpone client's destruction (usually following
     1477            // the call to del_trigger())
     1478            {
     1479              GMonitorLock lock(&trigger->disabled);
     1480              if (!trigger->disabled)
     1481                call_callback(trigger->callback, trigger->cl_data);
     1482            }
     1483
     1484            // Finally - remove the trigger from the list.
     1485            GCriticalSectionLock list_lock(&triggers_lock);
     1486            for(GPosition pos=triggers_list;pos;++pos)
     1487              if (triggers_list[pos]==trigger)
     1488                {
     1489                  triggers_list.del(pos);
     1490                  break;
     1491                }
     1492          } else break;
     1493      }
    14801494}
    14811495
     
    15041518      }else
    15051519      {
     1520         GP<DataPool> pool = this->pool;
    15061521         if (pool)
    15071522         {
     
    15681583   }
    15691584
     1585   GP<DataPool> pool = this->pool;
    15701586   if (pool)
    15711587     pool->del_trigger(callback, cl_data);
     
    15931609   DEBUG_MAKE_INDENT(3);
    15941610
     1611   GP<DataPool> pool = this->pool;
    15951612   if (pool)
    15961613   {
  • trunk/libdjvu/DataPool.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DataPool.h,v 1.12 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DataPool.h,v 1.13 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DATAPOOL_H
     
    9999    @memo Thread safe data storage
    100100    @author Andrei Erofeev <eaf@geocities.com>
    101     @version #$Id: DataPool.h,v 1.12 2007/03/25 20:48:29 leonb Exp $#
     101    @version #$Id: DataPool.h,v 1.13 2007/05/19 03:07:33 leonb Exp $#
    102102*/
    103103
     
    225225*/
    226226
    227 class DataPool : public GPEnabled
     227class DJVUAPI DataPool : public GPEnabled
    228228{
    229229public: // Classes used internally by DataPool
  • trunk/libdjvu/DjVmDir.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVmDir.cpp,v 1.13 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVmDir.cpp,v 1.14 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    452452            }
    453453        }
    454      
     454
    455455      GP<ByteStream> gbs_str=BSByteStream::create(gstr, 50);
    456456      ByteStream &bs_str=*gbs_str;
     
    463463      DEBUG_MSG("storing and compressing flags for every record\n");
    464464      const bool xdo_rename=(do_rename||!bundled);
    465       for(pos=files_list;pos;++pos)
    466         {
    467           const GP<File> file(files_list[pos]);
    468           if(xdo_rename)
    469             {
    470               const GUTF8String new_id = file->name;
    471               if (! new_id)
    472                 if(!file->oldname.length() || file->oldname == new_id)
    473                   file->flags &= ~File::HAS_NAME;
    474                 else
    475                   file->flags |= File::HAS_NAME;
    476             }
    477           else
    478             {
    479               if (!file->name.length() || file->name == file->id)
    480                 file->flags &= ~File::HAS_NAME;
    481               else
    482                 file->flags |= File::HAS_NAME;
    483             }
    484           if (file->title.length() && (file->title!=file->id))
    485             file->flags |= File::HAS_TITLE;
    486           else
    487             file->flags &= ~File::HAS_TITLE;
    488 
    489        bs_str.write8(file->flags);
    490      }
     465      for (pos=files_list;pos;++pos)
     466        {
     467          const GP<File> file(files_list[pos]);
     468          if (xdo_rename)
     469            {
     470              const GUTF8String new_id = file->name;
     471              if (!new_id)
     472                {
     473                  if (!file->oldname.length() || file->oldname == new_id)
     474                    file->flags &= ~File::HAS_NAME;
     475                  else
     476                    file->flags |= File::HAS_NAME;
     477                }
     478            }
     479          else
     480            {
     481              if (!file->name.length() || file->name == file->id)
     482                file->flags &= ~File::HAS_NAME;
     483              else
     484                file->flags |= File::HAS_NAME;
     485            }
     486          if (file->title.length() && (file->title!=file->id))
     487            file->flags |= File::HAS_TITLE;
     488          else
     489            file->flags &= ~File::HAS_TITLE;
     490
     491          bs_str.write8(file->flags);
     492        }
    491493
    492494     DEBUG_MSG("storing and compressing names...\n");
  • trunk/libdjvu/DjVmDir.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVmDir.h,v 1.12 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVmDir.h,v 1.14 2007/07/29 16:23:51 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVMDIR_H
     
    114114    @author Andrei Erofeev <eaf@geocities.com>
    115115    @version
    116     #$Id: DjVmDir.h,v 1.12 2007/03/25 20:48:29 leonb Exp $# */
     116    #$Id: DjVmDir.h,v 1.14 2007/07/29 16:23:51 leonb Exp $# */
    117117//@{
    118118
     
    152152    return a pointer to #DjVmDir# in some cases. */
    153153
    154 class DjVmDir : public GPEnabled
     154class DJVUAPI DjVmDir : public GPEnabled
    155155{
    156156protected:
     
    176176              const bool bundled, const bool do_rename) const;
    177177      /** Tests if directory defines an {\em indirect} document. */
    178    bool is_indirect(void) const;
     178   inline bool is_indirect(void) const;
    179179      /** Tests if the directory defines a {\em bundled} document. */
    180    bool is_bundled(void) const;
     180   inline bool is_bundled(void) const;
    181181      /** Translates page numbers to file records. */
    182182   GP<File> page_to_file(int page_num) const;
     
    227227};
    228228
    229 class DjVmDir::File : public GPEnabled
     229class DJVUAPI DjVmDir::File : public GPEnabled
    230230{
    231231public:
  • trunk/libdjvu/DjVmDir0.cpp

    r206 r280  
    5555//
    5656// $Id: DjVmDir0.cpp,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVmDir0.h

    r206 r280  
    5555//
    5656// $Id: DjVmDir0.h,v 1.9 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVMDIR0_H
  • trunk/libdjvu/DjVmDoc.cpp

    r206 r280  
    5555//
    5656// $Id: DjVmDoc.cpp,v 1.11 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVmDoc.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVmDoc.h,v 1.11 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVmDoc.h,v 1.12 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVMDOC_H
     
    8888    @memo DjVu multipage documents reader/writer.
    8989    @author Andrei Erofeev <eaf@geocities.com>
    90     @version #$Id: DjVmDoc.h,v 1.11 2007/03/25 20:48:29 leonb Exp $#
     90    @version #$Id: DjVmDoc.h,v 1.12 2007/05/19 03:07:33 leonb Exp $#
    9191*/
    9292
     
    117117*/
    118118
    119 class DjVmDoc : public GPEnabled
     119class DJVUAPI DjVmDoc : public GPEnabled
    120120{
    121121      // Internal function.
  • trunk/libdjvu/DjVmNav.cpp

    r206 r280  
    5555//
    5656// $Id: DjVmNav.cpp,v 1.2 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVmNav.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVmNav.h,v 1.2 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVmNav.h,v 1.3 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVMNAV_H
     
    8686**/
    8787
    88 class DjVmNav : public GPEnabled
     88class DJVUAPI DjVmNav : public GPEnabled
    8989{
    9090public:
     
    121121**/
    122122
    123 class DjVmNav::DjVuBookMark : public GPEnabled
     123class DJVUAPI DjVmNav::DjVuBookMark : public GPEnabled
    124124{
    125125protected:
  • trunk/libdjvu/DjVuAnno.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuAnno.cpp,v 1.14 2007/03/25 20:48:29 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuAnno.cpp,v 1.15 2007/12/02 03:58:29 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    244244             {
    245245               char buf[8];
    246                static char *tr1 = "\"\\tnrbf";
    247                static char *tr2 = "\"\\\t\n\r\b\f";
     246               static const char *tr1 = "\"\\tnrbf";
     247               static const char *tr2 = "\"\\\t\n\r\b\f";
    248248               sprintf(buf,"\\%03o", (int)(((unsigned char*)data)[span]));
    249249               for (int i=0; tr2[i]; i++)
     
    475475               else
    476476                 {
    477                    static char *tr1 = "tnrbfva";
    478                    static char *tr2 = "\t\n\r\b\f\013\007";
     477                   static const char *tr1 = "tnrbfva";
     478                   static const char *tr2 = "\t\n\r\b\f\013\007";
    479479                   for (int i=0; tr1[i]; i++)
    480480                     if (c == tr1[i])
  • trunk/libdjvu/DjVuAnno.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuAnno.h,v 1.9 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuAnno.h,v 1.10 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUANNO_H
     
    8888    @author Andrei Erofeev <eaf@geocities.com>
    8989    @version
    90     #$Id: DjVuAnno.h,v 1.9 2007/03/25 20:48:30 leonb Exp $# */
     90    #$Id: DjVuAnno.h,v 1.10 2007/05/19 03:07:33 leonb Exp $# */
    9191//@{
    9292
     
    113113    \Ref{DjVuANT::encode}() functions. */
    114114
    115 class DjVuANT : public GPEnabled
     115class DJVUAPI DjVuANT : public GPEnabled
    116116{
    117117protected:
     
    235235    (like \Ref{ANT}). The real work of encoding and decoding is done by
    236236    lower-level classes. */
    237 class DjVuAnno : public GPEnabled
     237class DJVUAPI DjVuAnno : public GPEnabled
    238238{
    239239protected:
  • trunk/libdjvu/DjVuDocEditor.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDocEditor.cpp,v 1.15 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDocEditor.cpp,v 1.23 2008/09/28 12:46:14 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    7878
    7979#include <ctype.h>
    80 
    8180
    8281#ifdef HAVE_NAMESPACES
     
    135134DjVuDocEditor::~DjVuDocEditor(void)
    136135{
    137    if (!tmp_doc_url.is_empty())
    138    {
    139      tmp_doc_url.deletefile();
    140    }
    141 
    142136   GCriticalSectionLock lock(&thumb_lock);
    143137   thumb_map.empty();
     
    193187       orig_doc_type==SINGLE_PAGE)
    194188   {
    195          // Suxx. I need to convert it NOW.
    196          // We will unlink this file in the destructor
    197       tmp_doc_url=GURL::Filename::Native(tmpnam(0));
    198       const GP<ByteStream> gstr(ByteStream::create(tmp_doc_url, "wb"));
    199       tmp_doc->write(gstr, true);        // Force DJVM format
    200       gstr->flush();
    201       doc_pool=DataPool::create(tmp_doc_url);
     189     // Suxx. I need to convert it now.
     190     GP<ByteStream> gstr = ByteStream::create();  // Convert in memory.
     191     tmp_doc->write(gstr, true);  // Force DJVM format
     192     gstr->seek(0);                     
     193     doc_pool=DataPool::create(gstr);
    202194   }
    203195
    204196      // OK. Now doc_pool contains data of the document in one of the
    205197      // new formats. It will be a lot easier to insert/delete pages now.
    206 
    207198      // 'doc_url' below of course doesn't refer to the file with the converted
    208199      // data, but we will take care of it by redirecting the request_data().
     
    11631154DjVuDocEditor::move_page(int page_num, int new_page_num)
    11641155{
    1165    DEBUG_MSG("DjVuDocEditor::move_page(): page_num=" << page_num <<
    1166              ", new_page_num=" << new_page_num << "\n");
    1167    DEBUG_MAKE_INDENT(3);
    1168 
    1169    if (page_num==new_page_num) return;
    1170 
    1171    int pages_num=get_pages_num();
    1172    if (page_num<0 || page_num>=pages_num)
    1173       G_THROW( ERR_MSG("DjVuDocEditor.bad_page") "\t"+GUTF8String(page_num));
    1174 
    1175    const GUTF8String id(page_to_id(page_num));
    1176    int file_pos=-1;
    1177    if (new_page_num>=0 && new_page_num<pages_num)
     1156  DEBUG_MSG("DjVuDocEditor::move_page(): page_num=" << page_num <<
     1157            ", new_page_num=" << new_page_num << "\n");
     1158  DEBUG_MAKE_INDENT(3);
     1159
     1160  if (page_num==new_page_num) return;
     1161
     1162  int pages_num=get_pages_num();
     1163  if (page_num<0 || page_num>=pages_num)
     1164    G_THROW( ERR_MSG("DjVuDocEditor.bad_page") "\t"+GUTF8String(page_num));
     1165
     1166  const GUTF8String id(page_to_id(page_num));
     1167  int file_pos=-1;
     1168  if (new_page_num>=0 && new_page_num<pages_num)
     1169    {
    11781170      if (new_page_num>page_num)        // Moving toward the end
    1179       {
    1180          if (new_page_num<pages_num-1)
    1181             file_pos=djvm_dir->get_page_pos(new_page_num+1)-1;
    1182       } else
    1183          file_pos=djvm_dir->get_page_pos(new_page_num);
    1184 
    1185    GMap<GUTF8String, void *> map;
    1186    move_file(id, file_pos, map);
    1187 }
     1171        {
     1172          if (new_page_num<pages_num-1)
     1173            file_pos=djvm_dir->get_page_pos(new_page_num+1)-1;
     1174        }
     1175      else
     1176        file_pos=djvm_dir->get_page_pos(new_page_num);
     1177    }
     1178
     1179  GMap<GUTF8String, void *> map;
     1180  move_file(id, file_pos, map);
     1181}
     1182
    11881183#ifdef _WIN32_WCE_EMULATION         // Work around odd behavior under WCE Emulation
    11891184#define CALLINGCONVENTION __cdecl
     
    19311926         // Assume, that we just want to 'save'. Check, that it's possible
    19321927         // and proceed.
    1933       bool can_be_saved_bundled=orig_doc_type==BUNDLED ||
    1934                                 orig_doc_type==OLD_BUNDLED ||
    1935                                 orig_doc_type==SINGLE_PAGE ||
    1936                                 orig_doc_type==OLD_INDEXED && orig_doc_pages==1;
     1928      bool can_be_saved_bundled =
     1929        orig_doc_type==BUNDLED ||
     1930        orig_doc_type==OLD_BUNDLED ||
     1931        orig_doc_type==SINGLE_PAGE ||
     1932        (orig_doc_type==OLD_INDEXED && orig_doc_pages==1);
    19371933      if ((bundled ^ can_be_saved_bundled)!=0)
    19381934         G_THROW( ERR_MSG("DjVuDocEditor.cant_save2") );
     
    19701966   }else
    19711967   {
    1972      if (djvm_dir->get_files_num()==1)
     1968     if (djvm_dir->get_files_num()==1 && !djvm_nav)
    19731969     {
    19741970       // Here 'bundled' has no effect: we will save it as one page.
     
    20512047       djvm_dir->encode(giff->get_bytestream());
    20522048       iff.close_chunk();
     2049       if (djvm_nav)
     2050         {
     2051           iff.put_chunk("NAVM");
     2052           djvm_nav->encode(iff.get_bytestream());
     2053           iff.close_chunk();
     2054         }
    20532055       iff.close_chunk();
    20542056       iff.flush();
     
    20952097        // of file url composition.
    20962098     for(GPosition pos=files_map;pos;)
    2097      {
    2098         const GP<File> file_rec(files_map[pos]);
    2099         file_rec->pool=0;
    2100         if (file_rec->file==0)
    2101         {
    2102          GPosition this_pos=pos;
    2103          ++pos;
    2104          files_map.del(this_pos);
    2105         } else
    2106         {
    2107             // Change the file's url;
    2108          if (doc_url!=save_doc_url ||
    2109              orig_doc_type!=save_doc_type)
    2110             if (save_doc_type==BUNDLED)
    2111                file_rec->file->move(save_doc_url);
    2112             else file_rec->file->move(save_doc_url.base());
    2113          ++pos;
    2114         }
    2115      }
    2116 
     2099       {
     2100         const GP<File> file_rec(files_map[pos]);
     2101         file_rec->pool=0;
     2102         if (file_rec->file==0)
     2103           {
     2104             GPosition this_pos=pos;
     2105             ++pos;
     2106             files_map.del(this_pos);
     2107           } else
     2108           {
     2109             // Change the file's url;
     2110             if (doc_url!=save_doc_url ||
     2111                 orig_doc_type!=save_doc_type)
     2112               {
     2113                 if (save_doc_type==BUNDLED)
     2114                   file_rec->file->move(save_doc_url);
     2115                 else
     2116                   file_rec->file->move(save_doc_url.base());
     2117               }
     2118             ++pos;
     2119           }
     2120       }
    21172121   }
    21182122   orig_doc_type=save_doc_type;
  • trunk/libdjvu/DjVuDocEditor.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDocEditor.h,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDocEditor.h,v 1.12 2008/09/28 12:46:14 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUDOCEDITOR_H
     
    8585    @memo DjVu document editor class.
    8686    @author Andrei Erofeev <eaf@geocities.com>
    87     @version #$Id: DjVuDocEditor.h,v 1.10 2007/03/25 20:48:30 leonb Exp $#
     87    @version #$Id: DjVuDocEditor.h,v 1.12 2008/09/28 12:46:14 leonb Exp $#
    8888*/
    8989
     
    104104*/
    105105
    106 class DjVuDocEditor : public DjVuDocument
     106class DJVUAPI DjVuDocEditor : public DjVuDocument
    107107{
    108108public:
     
    404404   GURL         doc_url;
    405405   GP<DataPool> doc_pool;
    406    GURL         tmp_doc_url;
    407406   int          orig_doc_type;
    408407   int          orig_doc_pages;
  • trunk/libdjvu/DjVuDocument.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDocument.cpp,v 1.17 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDocument.cpp,v 1.21 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    666666DjVuDocument::get_pages_num(void) const
    667667{
    668    check();
    669    if (flags & DOC_TYPE_KNOWN)
     668  check();
     669  if (flags & DOC_TYPE_KNOWN)
     670    {
    670671      if (doc_type==BUNDLED || doc_type==INDIRECT)
    671          return djvm_dir->get_pages_num();
     672        return djvm_dir->get_pages_num();
    672673      else if (flags & DOC_NDIR_KNOWN)
    673          return ndir->get_pages_num();
    674    return 1;
     674        return ndir->get_pages_num();
     675    }
     676  return 1;
    675677}
    676678
     
    687689      {
    688690         case SINGLE_PAGE:
     691         {
     692           if (page_num<1)
     693             url=init_url;
     694           else
     695             G_THROW( ERR_MSG("DjVuDocument.big_num") );
     696           break;
     697         }
    689698         case OLD_INDEXED:
    690699         {
    691             if (page_num<0) url=init_url;
    692             else if (flags & DOC_NDIR_KNOWN) url=ndir->page_to_url(page_num);
     700            if (page_num<0)
     701              url=init_url;
     702            else if (flags & DOC_NDIR_KNOWN)
     703              url=ndir->page_to_url(page_num);
    693704            break;
    694705         }
    695706         case OLD_BUNDLED:
    696707         {
    697             if (page_num<0) page_num=0;
     708            if (page_num<0)
     709              page_num=0;
    698710            if (page_num==0 && (flags & DOC_DIR_KNOWN))
    699                url=GURL::UTF8(first_page_name,init_url);
     711              url=GURL::UTF8(first_page_name,init_url);
    700712            else if (flags & DOC_NDIR_KNOWN)
    701                url=ndir->page_to_url(page_num);
     713              url=ndir->page_to_url(page_num);
    702714            break;
    703715         }
     
    709721            {
    710722              GP<DjVmDir::File> file=djvm_dir->page_to_file(page_num);
    711               if (!file) G_THROW( ERR_MSG("DjVuDocument.big_num") );
     723              if (!file)
     724                G_THROW( ERR_MSG("DjVuDocument.big_num") );
    712725              url=GURL::UTF8(file->get_load_name(),init_url);
    713726            }
     
    17891802
    17901803void
    1791 DjVuDocument::save_as(const GURL &where, const bool bundled)
     1804DjVuDocument::save_as(const GURL &where, bool bundled)
    17921805{
    17931806   DEBUG_MSG("DjVuDocument::save_as(): where='" << where <<
  • trunk/libdjvu/DjVuDocument.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDocument.h,v 1.11 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDocument.h,v 1.13 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUDOCUMENT_H
     
    9393    @memo DjVu document class.
    9494    @author Andrei Erofeev <eaf@geocities.com>
    95     @version #$Id: DjVuDocument.h,v 1.11 2007/03/25 20:48:30 leonb Exp $#
     95    @version #$Id: DjVuDocument.h,v 1.13 2008/01/27 11:36:27 leonb Exp $#
    9696*/
    9797
     
    214214    \end{enumerate} */
    215215   
    216 class DjVuDocument : public DjVuPort
     216class DJVUAPI DjVuDocument : public DjVuPort
    217217{
    218218public:
     
    758758                   index file. All document files will be saved into the
    759759                   save directory where the index file will resize. */
    760    virtual void         save_as(const GURL &where, const bool bundled=0);
     760   virtual void         save_as(const GURL &where, bool bundled=0);
    761761      //@}
    762762      /** Returns pointer to the internal directory of the document, if it
  • trunk/libdjvu/DjVuDumpHelper.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDumpHelper.cpp,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDumpHelper.cpp,v 1.11 2008/02/26 05:07:40 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    125125             GUTF8String, size_t, DjVmInfo&, int)
    126126{
    127   out_str.format( "JB2 colors data");
     127  GP<ByteStream> gbs = iff.get_bytestream();
     128  int version = gbs->read8();
     129  int size = gbs->read16();
     130  out_str.format( "JB2 colors data, v%d, %d colors",
     131                  version & 0x7f, size);
    128132}
    129133
     
    159163      unsigned char ylo = gbs->read8();
    160164      out_str.format( ", v%d.%d (%s), %dx%d", major & 0x7f, minor,
    161                       (major & 0x80 ? "b&w" : "color"), (xhi<<8)+xlo, (yhi<<8)+ylo );
     165                      (major & 0x80 ? "b&w" : "color"),
     166                      (xhi<<8)+xlo, (yhi<<8)+ylo );
    162167    }
    163168}
  • trunk/libdjvu/DjVuDumpHelper.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuDumpHelper.h,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuDumpHelper.h,v 1.11 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUDUMPHELPER_H
     
    7878    Andrei Erofeev <eaf@geocities.com> -- as a class.
    7979    @version
    80     #$Id: DjVuDumpHelper.h,v 1.10 2007/03/25 20:48:30 leonb Exp $# */
     80    #$Id: DjVuDumpHelper.h,v 1.11 2007/05/19 03:07:33 leonb Exp $# */
    8181//@{
    8282
     
    100100 */
    101101
    102 class DjVuDumpHelper
     102class DJVUAPI DjVuDumpHelper
    103103{
    104104public:
  • trunk/libdjvu/DjVuErrorList.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuErrorList.cpp,v 1.9 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuErrorList.h

    r206 r280  
    5555//
    5656// $Id: DjVuErrorList.h,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUERRORLIST_H
  • trunk/libdjvu/DjVuFile.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuFile.cpp,v 1.15 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuFile.cpp,v 1.17 2009/05/06 12:57:49 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    498498      GP<DjVuFile> & f=inc_files_list[pos];
    499499      if (f->is_decode_failed())
    500         G_THROW( ERR_MSG("DjVuFile.decode_fail") );
     500        G_THROW( ERR_MSG("DjVuFile.decode_fail") );
    501501      if (f->is_decode_stopped())
    502         G_THROW( DataPool::Stop );
     502        G_THROW( DataPool::Stop );
    503503      if (!f->is_decode_ok())
    504       {
    505         DEBUG_MSG("this_url='" << url << "'\n");
    506         DEBUG_MSG("incl_url='" << f->get_url() << "'\n");
    507         DEBUG_MSG("decoding=" << f->is_decoding() << "\n");
    508         DEBUG_MSG("status='" << f->get_flags() << "\n");
    509         G_THROW( ERR_MSG("DjVuFile.not_finished") );
    510       }
     504        {
     505          DEBUG_MSG("this_url='" << url << "'\n");
     506          DEBUG_MSG("incl_url='" << f->get_url() << "'\n");
     507          DEBUG_MSG("decoding=" << f->is_decoding() << "\n");
     508          DEBUG_MSG("status='" << f->get_flags() << "\n");
     509          G_THROW( ERR_MSG("DjVuFile.not_finished") );
     510        }
    511511    }
    512512  } G_CATCH(exc) {
    513513    G_TRY {
    514514      if (!exc.cmp_cause(DataPool::Stop))
    515       {
    516         flags.enter();
    517         flags=flags & ~DECODING | DECODE_STOPPED;
    518         flags.leave();
    519         pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.stopped"))
    520                               + GUTF8String("\t") + GUTF8String(url));
    521         pcaster->notify_file_flags_changed(this, DECODE_STOPPED, DECODING);
    522       } else
    523       {
    524         flags.enter();
    525         flags=flags & ~DECODING | DECODE_FAILED;
    526         flags.leave();
    527         pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.failed"))
    528                               + GUTF8String("\t") + GUTF8String(url));
    529         pcaster->notify_error(this, exc.get_cause());
    530         pcaster->notify_file_flags_changed(this, DECODE_FAILED, DECODING);
    531       }
     515        {
     516          flags.enter();
     517          flags = (flags & ~DECODING) | DECODE_STOPPED;
     518          flags.leave();
     519          pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.stopped"))
     520                                + GUTF8String("\t") + GUTF8String(url));
     521          pcaster->notify_file_flags_changed(this, DECODE_STOPPED, DECODING);
     522        } else
     523        {
     524          flags.enter();
     525          flags = (flags & ~DECODING) | DECODE_FAILED;
     526          flags.leave();
     527          pcaster->notify_status(this, GUTF8String(ERR_MSG("DjVuFile.failed"))
     528                                + GUTF8String("\t") + GUTF8String(url));
     529          pcaster->notify_error(this, exc.get_cause());
     530          pcaster->notify_file_flags_changed(this, DECODE_FAILED, DECODING);
     531        }
    532532    } G_CATCH_ALL
    533     {
    534       DEBUG_MSG("******* Oops. Almost missed an exception\n");
    535     } G_ENDCATCH;
     533        {
     534          DEBUG_MSG("******* Oops. Almost missed an exception\n");
     535        } G_ENDCATCH;
    536536  } G_ENDCATCH;
    537  
     537
    538538  decode_data_pool->clear_stream();
    539539  G_TRY {
     
    609609      // decoder to resolve all chunk dependencies, and
    610610      // abort decoding if necessary.
    611      
    612       // G_EXTHROW(ex); /* commented out */
    613611     
    614612      get_portcaster()->notify_error(this,ex.get_cause());
     
    667665    if(throw_errors)
    668666    {
    669       G_EXTHROW(ex);
     667      G_EMTHROW(ex);
    670668    }else
    671669    {
     
    682680    if(throw_errors)
    683681    {
    684       G_EXTHROW(ex, msg);
     682      G_EMTHROW(GException(msg, ex.get_file(), ex.get_line(),
     683                           ex.get_function() ));
    685684    }else
    686685    {
     
    15881587    ByteStream &str_out=*gstr_out;
    15891588    map[url]=0;
    1590    
     1589
    15911590    // Do the included files first (To make sure that they have
    15921591    // less precedence)
     
    15971596    for(GPosition pos=list;pos;++pos)
    15981597      get_merged_anno(list[pos], gstr_out, ignore_list, level+1, max_level, map);
    1599    
     1598
    16001599    // Now process the DjVuFile's own annotations
    16011600    if (!ignore_list.contains(file->get_url()))
    1602     {
    1603       if (!file->is_data_present() ||
    1604         file->is_modified() && file->anno)
    1605       {
    1606                // Process the decoded (?) anno
    1607         GCriticalSectionLock lock(&file->anno_lock);
    1608         if (file->anno && file->anno->size())
    1609         {
    1610           if (str_out.tell())
    1611           {
    1612             str_out.write((void *) "", 1);
    1613           }
    1614           file->anno->seek(0);
    1615           str_out.copy(*file->anno);
    1616         }
    1617       } else if (file->is_data_present())
    1618       {
    1619                // Copy all annotations chunks, but do NOT modify
    1620                // this->anno (to avoid correlation with DjVuFile::decode())
    1621         const GP<ByteStream> str(file->data_pool->get_stream());
    1622         const GP<IFFByteStream> giff(IFFByteStream::create(str));
    1623         IFFByteStream &iff=*giff;
    1624         GUTF8String chkid;
    1625         if (iff.get_chunk(chkid))
    1626           while(iff.get_chunk(chkid))
    1627           {
    1628             if (chkid=="FORM:ANNO")
    1629             {
    1630               if (max_level<level)
    1631                 max_level=level;
    1632               if (str_out.tell())
    1633               {
    1634                 str_out.write((void *) "", 1);
    1635               }
    1636               str_out.copy(*iff.get_bytestream());
    1637             }
    1638             else if (is_annotation(chkid)) // but not FORM:ANNO
    1639             {
    1640               if (max_level<level)
    1641                 max_level=level;
    1642               if (str_out.tell()&&chkid != "ANTz")
    1643               {
    1644                 str_out.write((void *) "", 1);
    1645               }
    1646               const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1647               IFFByteStream &iff_out=*giff_out;
    1648               iff_out.put_chunk(chkid);
    1649               iff_out.copy(*iff.get_bytestream());
    1650               iff_out.close_chunk();
    1651             }
    1652             iff.close_chunk();
    1653           }
    1654         file->data_pool->clear_stream();
    1655       }
    1656     }
     1601      {
     1602        if (!file->is_data_present() ||
     1603            (file->is_modified() && file->anno))
     1604          {
     1605            // Process the decoded (?) anno
     1606            GCriticalSectionLock lock(&file->anno_lock);
     1607            if (file->anno && file->anno->size())
     1608              {
     1609                if (str_out.tell())
     1610                  {
     1611                    str_out.write((void *) "", 1);
     1612                  }
     1613                file->anno->seek(0);
     1614                str_out.copy(*file->anno);
     1615              }
     1616          } else if (file->is_data_present())
     1617          {
     1618            // Copy all annotations chunks, but do NOT modify
     1619            // this->anno (to avoid correlation with DjVuFile::decode())
     1620            const GP<ByteStream> str(file->data_pool->get_stream());
     1621            const GP<IFFByteStream> giff(IFFByteStream::create(str));
     1622            IFFByteStream &iff=*giff;
     1623            GUTF8String chkid;
     1624            if (iff.get_chunk(chkid))
     1625              while(iff.get_chunk(chkid))
     1626                {
     1627                  if (chkid=="FORM:ANNO")
     1628                    {
     1629                      if (max_level<level)
     1630                        max_level=level;
     1631                      if (str_out.tell())
     1632                        {
     1633                          str_out.write((void *) "", 1);
     1634                        }
     1635                      str_out.copy(*iff.get_bytestream());
     1636                    }
     1637                  else if (is_annotation(chkid)) // but not FORM:ANNO
     1638                    {
     1639                      if (max_level<level)
     1640                        max_level=level;
     1641                      if (str_out.tell()&&chkid != "ANTz")
     1642                        {
     1643                          str_out.write((void *) "", 1);
     1644                        }
     1645                      const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1646                      IFFByteStream &iff_out=*giff_out;
     1647                      iff_out.put_chunk(chkid);
     1648                      iff_out.copy(*iff.get_bytestream());
     1649                      iff_out.close_chunk();
     1650                    }
     1651                  iff.close_chunk();
     1652                }
     1653            file->data_pool->clear_stream();
     1654          }
     1655      }
    16571656  }
    16581657}
     
    17111710  ByteStream &str_out=*gstr_out;
    17121711  if (!file->is_data_present() ||
    1713     file->is_modified() && file->anno)
    1714   {
    1715     // Process the decoded (?) anno
    1716     GCriticalSectionLock lock(&file->anno_lock);
    1717     if (file->anno && file->anno->size())
    1718     {
    1719       if (str_out.tell())
    1720       {
    1721         str_out.write((void *) "", 1);
    1722       }
    1723       file->anno->seek(0);
    1724       str_out.copy(*file->anno);
    1725     }
    1726   } else if (file->is_data_present())
    1727   {
    1728                // Copy all anno chunks, but do NOT modify
    1729                // DjVuFile::anno (to avoid correlation with DjVuFile::decode())
    1730     const GP<ByteStream> str=file->data_pool->get_stream();
    1731     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1732     IFFByteStream &iff=*giff;
    1733     GUTF8String chkid;
    1734     if (iff.get_chunk(chkid))
    1735     {
    1736       while(iff.get_chunk(chkid))
    1737       {
    1738         if (is_annotation(chkid))
    1739         {
    1740           if (str_out.tell())
    1741           {
    1742             str_out.write((void *) "", 1);
    1743           }
    1744           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1745           IFFByteStream &iff_out=*giff_out;
    1746           iff_out.put_chunk(chkid);
    1747           iff_out.copy(*iff.get_bytestream());
    1748           iff_out.close_chunk();
    1749         }
    1750         iff.close_chunk();
    1751       }
    1752     }
    1753     file->data_pool->clear_stream();
    1754   }
     1712      (file->is_modified() && file->anno))
     1713    {
     1714      // Process the decoded (?) anno
     1715      GCriticalSectionLock lock(&file->anno_lock);
     1716      if (file->anno && file->anno->size())
     1717        {
     1718          if (str_out.tell())
     1719            {
     1720              str_out.write((void *) "", 1);
     1721            }
     1722          file->anno->seek(0);
     1723          str_out.copy(*file->anno);
     1724        }
     1725    } else if (file->is_data_present())
     1726    {
     1727      // Copy all anno chunks, but do NOT modify
     1728      // DjVuFile::anno (to avoid correlation with DjVuFile::decode())
     1729      const GP<ByteStream> str=file->data_pool->get_stream();
     1730      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1731      IFFByteStream &iff=*giff;
     1732      GUTF8String chkid;
     1733      if (iff.get_chunk(chkid))
     1734        {
     1735          while(iff.get_chunk(chkid))
     1736            {
     1737              if (is_annotation(chkid))
     1738                {
     1739                  if (str_out.tell())
     1740                    {
     1741                      str_out.write((void *) "", 1);
     1742                    }
     1743                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1744                  IFFByteStream &iff_out=*giff_out;
     1745                  iff_out.put_chunk(chkid);
     1746                  iff_out.copy(*iff.get_bytestream());
     1747                  iff_out.close_chunk();
     1748                }
     1749              iff.close_chunk();
     1750            }
     1751        }
     1752      file->data_pool->clear_stream();
     1753    }
    17551754}
    17561755
     
    17621761  ByteStream &str_out=*gstr_out;
    17631762  if (!file->is_data_present() ||
    1764     file->is_modified() && file->text)
    1765   {
    1766     // Process the decoded (?) text
    1767     GCriticalSectionLock lock(&file->text_lock);
    1768     if (file->text && file->text->size())
    1769     {
    1770       if (str_out.tell())
    1771       {
    1772         str_out.write((void *) "", 1);
    1773       }
    1774       file->text->seek(0);
    1775       str_out.copy(*file->text);
    1776     }
    1777   } else if (file->is_data_present())
    1778   {
    1779                // Copy all text chunks, but do NOT modify
    1780                // DjVuFile::text (to avoid correlation with DjVuFile::decode())
    1781     const GP<ByteStream> str=file->data_pool->get_stream();
    1782     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1783     IFFByteStream &iff=*giff;
    1784     GUTF8String chkid;
    1785     if (iff.get_chunk(chkid))
    1786     {
    1787       while(iff.get_chunk(chkid))
    1788       {
    1789         if (is_text(chkid))
    1790         {
    1791           if (str_out.tell())
    1792           {
    1793             str_out.write((void *) "", 1);
    1794           }
    1795           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1796           IFFByteStream &iff_out=*giff_out;
    1797           iff_out.put_chunk(chkid);
    1798           iff_out.copy(*iff.get_bytestream());
    1799           iff_out.close_chunk();
    1800         }
    1801         iff.close_chunk();
    1802       }
    1803     }
    1804     file->data_pool->clear_stream();
    1805   }
     1763      (file->is_modified() && file->text))
     1764    {
     1765      // Process the decoded (?) text
     1766      GCriticalSectionLock lock(&file->text_lock);
     1767      if (file->text && file->text->size())
     1768        {
     1769          if (str_out.tell())
     1770            {
     1771              str_out.write((void *) "", 1);
     1772            }
     1773          file->text->seek(0);
     1774          str_out.copy(*file->text);
     1775        }
     1776    } else if (file->is_data_present())
     1777    {
     1778      // Copy all text chunks, but do NOT modify
     1779      // DjVuFile::text (to avoid correlation with DjVuFile::decode())
     1780      const GP<ByteStream> str=file->data_pool->get_stream();
     1781      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1782      IFFByteStream &iff=*giff;
     1783      GUTF8String chkid;
     1784      if (iff.get_chunk(chkid))
     1785        {
     1786          while(iff.get_chunk(chkid))
     1787            {
     1788              if (is_text(chkid))
     1789                {
     1790                  if (str_out.tell())
     1791                    {
     1792                      str_out.write((void *) "", 1);
     1793                    }
     1794                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1795                  IFFByteStream &iff_out=*giff_out;
     1796                  iff_out.put_chunk(chkid);
     1797                  iff_out.copy(*iff.get_bytestream());
     1798                  iff_out.close_chunk();
     1799                }
     1800              iff.close_chunk();
     1801            }
     1802        }
     1803      file->data_pool->clear_stream();
     1804    }
    18061805}
    18071806
     
    18131812  ByteStream &str_out=*gstr_out;
    18141813  if (!file->is_data_present() ||
    1815     file->is_modified() && file->meta)
    1816   {
    1817     // Process the decoded (?) meta
    1818     GCriticalSectionLock lock(&file->meta_lock);
    1819     if (file->meta && file->meta->size())
    1820     {
    1821       if (str_out.tell())
    1822       {
    1823         str_out.write((void *) "", 1);
    1824       }
    1825       file->meta->seek(0);
    1826       str_out.copy(*file->meta);
    1827     }
    1828   } else if (file->is_data_present())
    1829   {
    1830                // Copy all meta chunks, but do NOT modify
    1831                // DjVuFile::meta (to avoid correlation with DjVuFile::decode())
    1832     const GP<ByteStream> str=file->data_pool->get_stream();
    1833     const GP<IFFByteStream> giff=IFFByteStream::create(str);
    1834     IFFByteStream &iff=*giff;
    1835     GUTF8String chkid;
    1836     if (iff.get_chunk(chkid))
    1837     {
    1838       while(iff.get_chunk(chkid))
    1839       {
    1840         if (is_meta(chkid))
    1841         {
    1842           if (str_out.tell())
    1843           {
    1844             str_out.write((void *) "", 1);
    1845           }
    1846           const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
    1847           IFFByteStream &iff_out=*giff_out;
    1848           iff_out.put_chunk(chkid);
    1849           iff_out.copy(*iff.get_bytestream());
    1850           iff_out.close_chunk();
    1851         }
    1852         iff.close_chunk();
    1853       }
    1854     }
    1855     file->data_pool->clear_stream();
    1856   }
     1814      (file->is_modified() && file->meta))
     1815    {
     1816      // Process the decoded (?) meta
     1817      GCriticalSectionLock lock(&file->meta_lock);
     1818      if (file->meta && file->meta->size())
     1819        {
     1820          if (str_out.tell())
     1821            {
     1822              str_out.write((void *) "", 1);
     1823            }
     1824          file->meta->seek(0);
     1825          str_out.copy(*file->meta);
     1826        }
     1827    } else if (file->is_data_present())
     1828    {
     1829      // Copy all meta chunks, but do NOT modify
     1830      // DjVuFile::meta (to avoid correlation with DjVuFile::decode())
     1831      const GP<ByteStream> str=file->data_pool->get_stream();
     1832      const GP<IFFByteStream> giff=IFFByteStream::create(str);
     1833      IFFByteStream &iff=*giff;
     1834      GUTF8String chkid;
     1835      if (iff.get_chunk(chkid))
     1836        {
     1837          while(iff.get_chunk(chkid))
     1838            {
     1839              if (is_meta(chkid))
     1840                {
     1841                  if (str_out.tell())
     1842                    {
     1843                      str_out.write((void *) "", 1);
     1844                    }
     1845                  const GP<IFFByteStream> giff_out(IFFByteStream::create(gstr_out));
     1846                  IFFByteStream &iff_out=*giff_out;
     1847                  iff_out.put_chunk(chkid);
     1848                  iff_out.copy(*iff.get_bytestream());
     1849                  iff_out.close_chunk();
     1850                }
     1851              iff.close_chunk();
     1852            }
     1853        }
     1854      file->data_pool->clear_stream();
     1855    }
    18571856}
    18581857
  • trunk/libdjvu/DjVuFile.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuFile.h,v 1.11 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUFILE_H
     
    105105    @memo Classes representing DjVu files.
    106106    @author Andrei Erofeev <eaf@geocities.com>
    107     @version #$Id: DjVuFile.h,v 1.11 2007/03/25 20:48:30 leonb Exp $#
     107    @version #$Id: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $#
    108108*/
    109109
     
    201201    too. */
    202202
    203 class DjVuFile : public DjVuPort
     203class DJVUAPI DjVuFile : public DjVuPort
    204204{
    205205public:
  • trunk/libdjvu/DjVuFileCache.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuFileCache.cpp,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuFileCache.h

    r206 r280  
    5555//
    5656// $Id: DjVuFileCache.h,v 1.9 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUFILECACHE_H
  • trunk/libdjvu/DjVuGlobal.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuGlobal.cpp,v 1.8 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuGlobal.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuGlobal.h,v 1.11 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuGlobal.h,v 1.12 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUGLOBAL_H
     
    8080#  define DJVUAPI __declspec(dllexport)
    8181# else
    82 #  ifdef LIBDJVU_DLL_IMPORT
    83 #   define DJVUAPI __declspec(dllimport)
    84 #  endif
     82#  define DJVUAPI __declspec(dllimport)
    8583# endif
    8684#endif
     
    103101    Global definitions.
    104102    @version
    105     #$Id: DjVuGlobal.h,v 1.11 2007/03/25 20:48:30 leonb Exp $#
     103    #$Id: DjVuGlobal.h,v 1.12 2007/05/19 03:07:33 leonb Exp $#
    106104    @author
    107105    L\'eon Bottou <leonb@research.att.com> -- empty file.\\
  • trunk/libdjvu/DjVuGlobalMemory.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuGlobalMemory.cpp,v 1.7 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuImage.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuImage.cpp,v 1.14 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuImage.cpp,v 1.17 2008/08/06 04:40:41 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    400400//// DJVUIMAGE: UTILITIES
    401401
    402 GUTF8String 
     402GUTF8String
    403403DjVuImage::get_short_description() const
    404404{
     
    407407  int height = get_height();
    408408  if (width && height)
    409     if (file && file->file_size>100)
    410       //msg.format("%dx%d in %0.1f Kb", width, height, file->file_size/1024.0);
    411       msg.format( ERR_MSG("DjVuImage.short1") "\t%d\t%d\t%0.1f", width, height, file->file_size/1024.0 );
    412     else
    413       //msg.format("%dx%d", width, height);
    414       msg.format( ERR_MSG("DjVuImage.short2") "\t%d\t%d", width, height );
     409    {
     410      if (file && file->file_size>100)
     411        //msg.format("%dx%d in %0.1f Kb", width, height, file->file_size/1024.0);
     412        msg.format( ERR_MSG("DjVuImage.short1") "\t%d\t%d\t%0.1f",
     413                    width, height, file->file_size/1024.0 );
     414      else
     415        //msg.format("%dx%d", width, height);
     416        msg.format( ERR_MSG("DjVuImage.short2") "\t%d\t%d", width, height );
     417    }
    415418  return msg;
    416419}
    417420
    418 GUTF8String 
     421GUTF8String
    419422DjVuImage::get_long_description() const
    420423{
     
    10751078          const GRect &inrect, const GRect &inall, int align )
    10761079{
    1077     GRect rect=inrect;
    1078     GRect all=inall;
    1079     if( dimg.get_rotate() )
    1080       {
    1081         GRectMapper mapper;
    1082         mapper.rotate(-dimg.get_rotate());
    1083         mapper.map(rect);
    1084         mapper.map(all);
    1085     }
    1086    
     1080  GRect rect=inrect;
     1081  GRect all=inall;
     1082  if (! dimg.get_info())
     1083    return 0;
     1084  if( dimg.get_rotate() )
     1085    {
     1086      GRectMapper mapper;
     1087      mapper.rotate(-dimg.get_rotate());
     1088      mapper.map(rect);
     1089      mapper.map(all);
     1090    }
    10871091  // Sanity
    10881092  if (! ( all.contains(rect.xmin, rect.ymin) &&
     
    11401144  GRect rect=inrect;
    11411145  GRect all=inall;
     1146  if (! dimg.get_info())
     1147    return 0;
    11421148  if( dimg.get_rotate()%4 )
    11431149    {
     
    11561162  w = dimg.get_real_width();
    11571163  h = dimg.get_real_height();
    1158 
    11591164  rw = all.width();
    11601165  rh = all.height();
  • trunk/libdjvu/DjVuImage.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuImage.h,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuImage.h,v 1.11 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUIMAGE_H
     
    103103    Andrei Erofeev <eaf@geocities.com> - multipage support
    104104    @version
    105     #$Id: DjVuImage.h,v 1.10 2007/03/25 20:48:30 leonb Exp $# */
     105    #$Id: DjVuImage.h,v 1.11 2007/05/19 03:07:33 leonb Exp $# */
    106106//@{
    107107
     
    138138    pixel representation of the desired segment of the DjVu image. */
    139139
    140 class DjVuImage : public DjVuPort
     140class DJVUAPI DjVuImage : public DjVuPort
    141141{
    142142protected:
  • trunk/libdjvu/DjVuInfo.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuInfo.cpp,v 1.11 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuInfo.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuInfo.h,v 1.16 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuInfo.h,v 1.17 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUINFO_H
     
    7676    L\'eon Bottou <leonb@research.att.com>
    7777    @version
    78     #$Id: DjVuInfo.h,v 1.16 2007/03/25 20:48:30 leonb Exp $# */
     78    #$Id: DjVuInfo.h,v 1.17 2008/01/27 11:36:27 leonb Exp $# */
    7979//@{
    8080
     
    126126 */
    127127
    128 class DjVuInfo : public GPEnabled
     128class DJVUAPI DjVuInfo : public GPEnabled
    129129{
    130130protected:
  • trunk/libdjvu/DjVuMessage.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuMessage.cpp,v 1.19 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuMessage.cpp,v 1.24 2008/01/27 17:32:56 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    7878#ifdef WIN32
    7979# include <tchar.h>
    80 # include <atlbase.h>
    8180# include <windows.h>
    8281# include <winreg.h>
     
    122121// directory names for searching messages
    123122#ifdef AUTOCONF
    124 // !!! ER !!! static const char DjVuDataDir[] = DIR_DATADIR "/djvu/osi";
     123static const char DjVuDataDir[] = DIR_DATADIR "/djvu/osi";
     124#endif /* AUTOCONF */
    125125static const char ModuleDjVuDir[] ="share/djvu/osi";
    126 #else /* !AUTOCONF */
    127 static const char ModuleDjVuDir[] ="profiles";
    128 #endif /* !AUTOCONF */
     126static const char ProfilesDjVuDir[] ="profiles";
    129127static const char LocalDjVuDir[] =".DjVu";      // relative to ${HOME}
    130128#ifdef LT_DEFAULT_PREFIX
     
    152150{
    153151  GURL retval;
    154    // To do:  This needs to be shared with SetProfile.cpp
    155152  LPCTSTR path = registrypath;
    156 
    157153  HKEY hKey = 0;
    158   // MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,argv[1],strlen(argv[1])+1,wszSrcFile,sizeof(wszSrcFile));
    159154  if (RegOpenKeyEx(hParentKey, path, 0,
    160               KEY_READ, &hKey) == ERROR_SUCCESS )
     155                   KEY_READ, &hKey) == ERROR_SUCCESS )
    161156  {
    162     TCHAR path[1024];
    163     // Success
    164     TCHAR *szPathValue = path;
    165     LPCTSTR lpszEntry = (LPCTSTR &)TEXT("");
    166     DWORD dwCount = (sizeof(path)/sizeof(TCHAR))-1;
     157    CHAR path[1024];
     158    CHAR *szPathValue = path;
     159    LPCSTR lpszEntry = "";
     160    DWORD dwCount = (sizeof(path)/sizeof(CHAR))-1;
    167161    DWORD dwType;
    168 
    169     LONG lResult = RegQueryValueEx(hKey, lpszEntry, NULL,
    170              &dwType, (LPBYTE) szPathValue, &dwCount);
    171 
     162    LONG lResult = RegQueryValueExA(hKey, lpszEntry, NULL,
     163                        &dwType, (LPBYTE)szPathValue, &dwCount);
    172164    RegCloseKey(hKey);
    173 
    174165    if ((lResult == ERROR_SUCCESS))
    175166    {
    176167      szPathValue[dwCount] = 0;
    177       USES_CONVERSION;
    178       retval=GURL::Filename::Native(T2CA(path));
     168      retval=GURL::Filename::Native(path);
    179169    }
    180170  }
    181 //  if (hKey)  RegCloseKey(hKey);
    182171  return retval;
    183172}
     
    187176{
    188177  const GUTF8String cwd(GOS::cwd());
    189   TCHAR path[1024];
    190   DWORD dwCount = (sizeof(path)/sizeof(TCHAR))-1;
    191   GetModuleFileName(0, path, dwCount);
    192   USES_CONVERSION;
    193   GURL retval=GURL::Filename::Native(T2CA(path)).base();
     178  CHAR path[1024];
     179  DWORD dwCount = (sizeof(path)/sizeof(CHAR))-1;
     180  GetModuleFileNameA(0, path, dwCount);
     181  GURL retval=GURL::Filename::Native(path).base();
    194182  GOS::cwd(cwd);
    195183  return retval;
     
    293281#endif
    294282      appendPath(mpath,pathsmap,paths);
     283      appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths);
     284      appendPath(GURL::UTF8(ProfilesDjVuDir,mpath),pathsmap,paths);
    295285      mpath=mpath.base();
    296286      appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths);
     287      appendPath(GURL::UTF8(ProfilesDjVuDir,mpath),pathsmap,paths);
    297288      mpath=mpath.base();
    298289      appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths);
     290      appendPath(GURL::UTF8(ProfilesDjVuDir,mpath),pathsmap,paths);
    299291      mpath=mpath.base();
    300292      appendPath(GURL::UTF8(ModuleDjVuDir,mpath),pathsmap,paths);
     293      appendPath(GURL::UTF8(ProfilesDjVuDir,mpath),pathsmap,paths);
    301294    }
    302295#endif
    303296#if defined(AUTOCONF)
    304     // ER !!! GURL dpath = GURL::Filename::UTF8(DjVuDataDir);
    305     // !!! appendPath(dpath,pathsmap,paths);
     297    GURL dpath = GURL::Filename::UTF8(DjVuDataDir);
     298    appendPath(dpath,pathsmap,paths);
    306299#endif
    307300#ifdef WIN32
  • trunk/libdjvu/DjVuMessage.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuMessage.h,v 1.10 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuMessage.h,v 1.11 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959
     
    8484class GURL;
    8585
    86 class DjVuMessage : public DjVuMessageLite
     86class DJVUAPI DjVuMessage : public DjVuMessageLite
    8787{
    8888protected:
  • trunk/libdjvu/DjVuMessageLite.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuMessageLite.cpp,v 1.14 2007/03/25 20:48:30 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuMessageLite.cpp,v 1.16 2008/03/10 20:32:45 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    8181#ifdef WIN32
    8282#include <tchar.h>
    83 #include <atlbase.h>
    8483#include <windows.h>
    8584#include <winreg.h>
     
    382381              break;
    383382            case 'f':
     383            case 'g':
     384            case 'e':
    384385              {
    385386                int endpos;
  • trunk/libdjvu/DjVuMessageLite.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuMessageLite.h,v 1.10 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuMessageLite.h,v 1.11 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef __DJVU_MESSAGE_LITE_H__
     
    150150  */
    151151
    152 class DjVuMessageLite : public GPEnabled
     152class DJVUAPI DjVuMessageLite : public GPEnabled
    153153{
    154154protected:
  • trunk/libdjvu/DjVuNavDir.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuNavDir.cpp,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuNavDir.h

    r206 r280  
    5555//
    5656// $Id: DjVuNavDir.h,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUNAVDIR_H
  • trunk/libdjvu/DjVuPalette.cpp

    r206 r280  
    5555//
    5656// $Id: DjVuPalette.cpp,v 1.13 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/DjVuPalette.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuPalette.h,v 1.10 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuPalette.h,v 1.11 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUPALETTE_H_
     
    8787    DjVuPalette header file
    8888    @version
    89     #$Id: DjVuPalette.h,v 1.10 2007/03/25 20:48:31 leonb Exp $#
     89    #$Id: DjVuPalette.h,v 1.11 2007/05/19 03:07:33 leonb Exp $#
    9090    @author:
    9191    L\'eon Bottou <leonb@research.att.com> */
     
    122122#endif
    123123
    124 class DjVuPalette : public GPEnabled
     124class DJVUAPI DjVuPalette : public GPEnabled
    125125{
    126126protected:
  • trunk/libdjvu/DjVuPort.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuPort.cpp,v 1.11 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuPort.cpp,v 1.13 2008/08/03 14:16:53 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    265265   if (pos && cont_map[pos] && ((DjVuPort *) port)->get_count()>0)
    266266      gp_port=port;
     267   if (gp_port && gp_port->get_count() <= 0)
     268      gp_port = 0;
    267269   return gp_port;
    268270}
  • trunk/libdjvu/DjVuPort.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuPort.h,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuPort.h,v 1.11 2007/07/14 01:21:56 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUPORT_H
     
    122122    @author Andrei Erofeev <eaf@geocities.com>\\
    123123            L\'eon Bottou <leonb@research.att.com>
    124     @version #$Id: DjVuPort.h,v 1.9 2007/03/25 20:48:31 leonb Exp $# */
     124    @version #$Id: DjVuPort.h,v 1.11 2007/07/14 01:21:56 leonb Exp $# */
    125125//@{
    126126
     
    141141    ``alive'' and never receive notifications! */
    142142
    143 class DjVuPort : public GPEnabled
     143class DJVUAPI DjVuPort : public GPEnabled
    144144{
    145145public:
     
    265265private:
    266266   static GCriticalSection      * corpse_lock;
    267    static DjVuPortCorpse        * corpse_head, * corpse_tail;
     267   static DjVuPortCorpse        * corpse_head;
     268   static DjVuPortCorpse        * corpse_tail;
    268269   static int                   corpse_num;
    269270};
     
    276277    are ignored. */
    277278
    278 class DjVuSimplePort : public DjVuPort
     279class DJVUAPI DjVuSimplePort : public DjVuPort
    279280{
    280281public:
     
    301302    \Ref{DjVuFile} to this port. */
    302303
    303 class DjVuMemoryPort : public DjVuPort
     304class DJVUAPI DjVuMemoryPort : public DjVuPort
    304305{
    305306public:
     
    356357    The user is not expected to create the #DjVuPortcaster# itself. He should
    357358    use \Ref{get_portcaster}() global function instead.  */
    358 class DjVuPortcaster
     359class DJVUAPI DjVuPortcaster
    359360{
    360361public:
  • trunk/libdjvu/DjVuText.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuText.cpp,v 1.11 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuText.cpp,v 1.12 2008/06/17 12:57:48 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    314314  if (!textUTF8)
    315315    return false;
    316   if (page_zone.children.isempty() || page_zone.rect.isempty())
     316  if (page_zone.rect.isempty())
    317317    return false;
    318318  return true;
  • trunk/libdjvu/DjVuText.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuText.h,v 1.11 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuText.h,v 1.12 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVUTEXT_H
     
    8585    @author Andrei Erofeev <eaf@geocities.com>
    8686    @version
    87     #$Id: DjVuText.h,v 1.11 2007/03/25 20:48:31 leonb Exp $# */
     87    #$Id: DjVuText.h,v 1.12 2008/01/27 11:36:27 leonb Exp $# */
    8888//@{
    8989
     
    109109    and a length describing a segment of a global UTF8 encoded string.  */
    110110
    111 class DjVuTXT : public GPEnabled
     111class DJVUAPI DjVuTXT : public GPEnabled
    112112{
    113113protected:
     
    124124  /** Data structure representing document textual components.
    125125      The text structure is represented by a hierarchy of rectangular zones. */
    126   class Zone
     126  class DJVUAPI Zone
    127127  {
    128128  public:
     
    225225
    226226
    227 class DjVuText : public GPEnabled
     227class DJVUAPI DjVuText : public GPEnabled
    228228{
    229229protected:
  • trunk/libdjvu/DjVuToPS.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: DjVuToPS.cpp,v 1.24 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: DjVuToPS.cpp,v 1.27 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    270270  DEBUG_MSG("Initializing dig2hex[]\n");
    271271  // Creating tables for bin=>text translation
    272   static char * dig2hex="0123456789ABCDEF";
     272  static const char * dig2hex="0123456789ABCDEF";
    273273  int i;
    274274  for(i=0;i<256;i++)
     
    12791279  buffer_size = buffer_size*23/10;
    12801280  bool do_color = options.get_color();
    1281   if (!dimg->is_legal_photo() &&
    1282       !dimg->is_legal_compound() ||
    1283       options.get_mode()==Options::BW)
     1281  if ((!dimg->is_legal_photo() &&
     1282       !dimg->is_legal_compound())
     1283      || options.get_mode()==Options::BW)
    12841284    do_color = false;
    12851285  if (do_color)
     
    19161916        {
    19171917          char buffer[5];
    1918           sprintf(buffer,"\\%03o", *data);
     1918          sprintf(buffer,"\\%03o", *(unsigned char*)data);
    19191919          out.write(buffer,4);
    19201920          data += 1;
  • trunk/libdjvu/DjVuToPS.h

    r206 r280  
    5555//
    5656// $Id: DjVuToPS.h,v 1.15 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _DJVU_TO_PS_H_
  • trunk/libdjvu/GBitmap.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GBitmap.cpp,v 1.13 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GBitmap.cpp,v 1.14 2007/07/14 01:21:56 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    7272#include <string.h>
    7373
    74 // File "$Id: GBitmap.cpp,v 1.13 2007/03/25 20:48:31 leonb Exp $"
     74// File "$Id: GBitmap.cpp,v 1.14 2007/07/14 01:21:56 leonb Exp $"
    7575// - Author: Leon Bottou, 05/1997
    7676
     
    810810    {
    811811      for (int c = 0; c<ncolumns; c++)
    812         row[c] = ramp[read_integer(lookahead, bs)];
     812        row[c] = ramp[(int)read_integer(lookahead, bs)];
    813813      row -= bytes_per_row;
    814814    }
  • trunk/libdjvu/GBitmap.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GBitmap.h,v 1.13 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GBitmap.h,v 1.14 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GBITMAP_H_
     
    104104    L\'eon Bottou <leonb@research.att.com>
    105105    @version
    106     #$Id: GBitmap.h,v 1.13 2007/03/25 20:48:31 leonb Exp $#
     106    #$Id: GBitmap.h,v 1.14 2007/05/19 03:07:33 leonb Exp $#
    107107
    108108 */
     
    128128    pixels because they are shared between images and between lines.  */
    129129
    130 class GBitmap : public GPEnabled
     130class DJVUAPI GBitmap : public GPEnabled
    131131{
    132132protected:
  • trunk/libdjvu/GContainer.cpp

    r206 r280  
    5555//
    5656// $Id: GContainer.cpp,v 1.15 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/GContainer.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GContainer.h,v 1.19 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GContainer.h,v 1.21 2008/01/07 11:48:52 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GCONTAINER_H_
     
    133133    Andrei Erofeev <eaf@geocities.com> -- bug fixes.
    134134    @version
    135     #$Id: GContainer.h,v 1.19 2007/03/25 20:48:31 leonb Exp $# */
     135    #$Id: GContainer.h,v 1.21 2008/01/07 11:48:52 leonb Exp $# */
    136136//@{
    137137
     
    282282    // Template based default constructor
    283283    static void init(void* dst, int n)
    284       { T* d = (T*)dst;   while (--n>=0) { new ((void*)d) T; d++; } }
     284      { T* d = (T*)dst; while (--n>=0) { new ((void*)d) T; d++; } }
    285285    // Template based copy constructor
    286286    static void copy(void* dst, const void* src, int n, int zap)
    287       { T* d = (T*)dst; const T *s = (const T*)src;
    288         while (--n>=0) { new ((void*)d) T(*s); if (zap) { s->T::~T(); }; d++; s++; } }
     287      { T* d = (T*)dst; T* s = (T*)src; while (--n>=0) {
     288          new ((void*)d) T(*s); if (zap) { s->~T(); }; d++; s++; } }
    289289    // Template based destructor
    290290    static void fini(void* dst, int n)
    291       { T* d = (T*)dst; while (--n>=0) { d->T::~T(); d++; } }
     291      { T* d = (T*)dst; while (--n>=0) { d->~T(); d++; } }
    292292  };
    293293  // --- Base class for list nodes
     
    389389//@{
    390390
    391 class GArrayBase : public GCont
     391class DJVUAPI GArrayBase : public GCont
    392392{
    393393public:
     
    764764*/
    765765
    766 class GPosition : protected GCont
     766class DJVUAPI GPosition : protected GCont
    767767{
    768768public:
     
    805805
    806806
    807 class GListBase : public GCont
     807class DJVUAPI GListBase : public GCont
    808808{
    809809protected:
     
    10741074//@{
    10751075
    1076 class GSetBase : public GCont
     1076class DJVUAPI GSetBase : public GCont
    10771077{
    10781078protected:
  • trunk/libdjvu/GException.cpp

    r206 r280  
    5555//
    5656// $Id: GException.cpp,v 1.15 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/GException.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GException.h,v 1.12 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GException.h,v 1.13 2007/12/26 09:05:26 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GEXCEPTION_H_
     
    119119    Andrei Erofeev <eaf@geocities.com> -- fixed message memory allocation.
    120120    @version
    121     #$Id: GException.h,v 1.12 2007/03/25 20:48:31 leonb Exp $# */
     121    #$Id: GException.h,v 1.13 2007/12/26 09:05:26 leonb Exp $# */
    122122//@{
    123123
     
    163163    only deal with exceptions of type #GException#. */
    164164
    165 class GException {
     165class DJVUAPI GException {
    166166public:
    167167  enum source_type { GINTERNAL=0, GEXTERNAL, GAPPLICATION, GOTHER };
     
    259259// Defined exception macros accordingly.
    260260
    261 class GExceptionHandler {
     261class DJVUAPI GExceptionHandler {
    262262public:
    263263#ifndef NO_LIBGCC_HOOKS
     
    288288// Emulate with setjmp/longjmp.
    289289
    290 class GExceptionHandler {
     290class DJVUAPI GExceptionHandler {
    291291public:
    292292  jmp_buf jump;
     
    325325
    326326
    327 inline void
    328 G_EXTHROW
    329 (const GException &ex,const char *msg=0,const char *file=0,int line=0,
    330   const char *func=0, const GException::source_type source=GException::GINTERNAL)
     327inline void G_EXTHROW(const GException &ex,
     328   const char *msg=0,const char *file=0,int line=0, const char *func=0,
     329   const GException::source_type source=GException::GINTERNAL)
    331330{
    332331  G_EMTHROW( (msg||file||line||func)?
     
    339338}
    340339
    341 inline void
    342 G_EXTHROW
    343 (const char msg[],const char *file=0,int line=0,const char *func=0,
    344   const GException::source_type source=GException::GINTERNAL )
     340inline void G_EXTHROW(const char msg[],
     341   const char *file=0,int line=0,const char *func=0,
     342   const GException::source_type source=GException::GINTERNAL )
    345343{
    346344  G_EMTHROW(GException(msg,file,line,func,source));
  • trunk/libdjvu/GIFFManager.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GIFFManager.cpp,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GIFFManager.cpp,v 1.10 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    118118  if (name.contains(".[]")>=0)
    119119    G_THROW( ERR_MSG("GIFFManager.bad_char") );
    120    
     120
    121121  strncpy(GIFFChunk::name, (const char *)name, 4);
    122122  GIFFChunk::name[4]=0;
     
    131131  const int colon=name.search(':');
    132132  if(colon>=0)
    133   {
    134     type=name.substr(0,colon);
    135     name=name.substr(colon+1,(unsigned int)-1);
    136   }
    137  
     133    {
     134      type=name.substr(0,colon);
     135      name=name.substr(colon+1,(unsigned int)-1);
     136    }
     137
    138138  const GUTF8String sname=(name.substr(0,4)+"    ").substr(0,4);
    139139
    140140  DEBUG_MSG("GIFFChunk::check_name(): type='" << type << "' name='" << sname << "'\n");
    141   return (type==GIFFChunk::type || !type.length() && GIFFChunk::type=="FORM")
    142        && sname==GIFFChunk::name;
     141  return (type==GIFFChunk::type || (!type.length() && GIFFChunk::type=="FORM"))
     142    && sname==GIFFChunk::name;
    143143}
    144144
  • trunk/libdjvu/GIFFManager.h

    r206 r280  
    5555//
    5656// $Id: GIFFManager.h,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GIFFMANAGER_H
  • trunk/libdjvu/GMapAreas.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GMapAreas.cpp,v 1.10 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GMapAreas.cpp,v 1.11 2008/08/05 20:50:35 bpearlmutter Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    464464
    465465   if (xmax<grect.xmin || xmin>grect.xmax ||
    466        ymax<grect.ymin || ymin>grect.ymax) return false;
     466       ymax<grect.ymin || ymin>grect.ymax)
     467     return false;
    467468
    468469   return
    469       x1>=grect.xmin && x1<=grect.xmax && y1>=grect.ymin && y1<=grect.ymax ||
    470       x2>=grect.xmin && x2<=grect.xmax && y2>=grect.ymin && y2<=grect.ymax ||
    471       do_segments_intersect(grect.xmin, grect.ymin, grect.xmax, grect.ymax,
    472                             x1, y1, x2, y2) ||
    473       do_segments_intersect(grect.xmax, grect.ymin, grect.xmin, grect.ymax,
    474                             x1, y1, x2, y2);
     470     (x1>=grect.xmin && x1<=grect.xmax && y1>=grect.ymin && y1<=grect.ymax) ||
     471     (x2>=grect.xmin && x2<=grect.xmax && y2>=grect.ymin && y2<=grect.ymax) ||
     472     do_segments_intersect(grect.xmin, grect.ymin, grect.xmax, grect.ymax,
     473                           x1, y1, x2, y2) ||
     474     do_segments_intersect(grect.xmax, grect.ymin, grect.xmin, grect.ymax,
     475                           x1, y1, x2, y2);
    475476}
    476477
     
    515516GMapPoly::check_data(void)
    516517{
    517   if (open && points<2 || !open && points<3)
     518  if ((open && points<2) || (!open && points<3))
    518519    return error_too_few_points;
    519520  for(int i=0;i<sides;i++)
    520   {
    521     for(int j=i+2;j<sides;j++)
    522521    {
    523       if (i != (j+1)%points )
    524       {
    525         if (do_segments_intersect(xx[i], yy[i], xx[i+1], yy[i+1],
     522      for(int j=i+2;j<sides;j++)
     523        {
     524          if (i != (j+1)%points )
     525            if (do_segments_intersect(xx[i], yy[i], xx[i+1], yy[i+1],
    526526                                      xx[j], yy[j], xx[(j+1)%points], yy[(j+1)%points]))
    527         {
    528           return error_intersect;
    529         }
    530       }
     527              return error_intersect;
     528        }
    531529    }
    532   }
    533530  return "";
    534531}
     
    537534GMapPoly::optimize_data(void)
    538535{
    539    // Removing segments of length zero
    540    int i;
    541    for(i=0;i<sides;i++)
    542    {
     536  // Removing segments of length zero
     537  int i;
     538  for(i=0;i<sides;i++)
     539    {
    543540      while(xx[i]==xx[(i+1)%points] && yy[i]==yy[(i+1)%points])
    544       {
    545          for(int k=(i+1)%points;k<points-1;k++)
    546          {
    547             xx[k]=xx[k+1]; yy[k]=yy[k+1];
    548          }
    549          points--; sides--;
    550          if (!points) return;
    551       }
    552    }
    553    // Concatenating consequitive parallel segments
    554    for(i=0;i<sides;i++)
    555    {
    556       while((open && i+1<sides || !open) &&
     541        {
     542          for(int k=(i+1)%points;k<points-1;k++)
     543            {
     544              xx[k]=xx[k+1]; yy[k]=yy[k+1];
     545            }
     546          points--; sides--;
     547          if (!points) return;
     548        }
     549    }
     550  // Concatenating consequitive parallel segments
     551  for(i=0;i<sides;i++)
     552    {
     553      while(((open && i+1<sides) || !open) &&
    557554            are_segments_parallel(xx[i], yy[i],
    558555                                  xx[(i+1)%points], yy[(i+1)%points],
    559556                                  xx[(i+1)%points], yy[(i+1)%points],
    560557                                  xx[(i+2)%points], yy[(i+2)%points]))
    561       {
    562          for(int k=(i+1)%points;k<points-1;k++)
    563          {
    564             xx[k]=xx[k+1]; yy[k]=yy[k+1];
    565          }
    566          points--; sides--;
    567          if (!points) return;
    568       }
    569    }
     558        {
     559          for(int k=(i+1)%points;k<points-1;k++)
     560            {
     561              xx[k]=xx[k+1]; yy[k]=yy[k+1];
     562            }
     563          points--; sides--;
     564          if (!points) return;
     565        }
     566    }
    570567}
    571568
     
    575572   if (open)
    576573     return false;
    577    
     574
    578575   int xfar=get_xmax()+(get_xmax()-get_xmin());
    579    
     576
    580577   int intersections=0;
    581578   for(int i=0;i<points;i++)
     
    595592         }
    596593      }
    597       if (res1<0 && res2>0 || res1>0 && res2<0)
     594      if ((res1<0 && res2>0) || (res1>0 && res2<0))
    598595      {
    599596         int x1=xx[i%points], y1=yy[i%points];
  • trunk/libdjvu/GMapAreas.h

    r206 r280  
    5555//
    5656// $Id: GMapAreas.h,v 1.9 2007/03/25 20:48:31 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GMAPAREAS_H
  • trunk/libdjvu/GOS.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GOS.cpp,v 1.14 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GOS.cpp,v 1.17 2008/03/10 13:58:54 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    7575#include <string.h>
    7676
    77 #ifdef WIN32
    78 # include <atlbase.h>
     77#if defined(__CYGWIN32__)
     78# define UNIX 1
     79#endif
     80
     81#if defined(WIN32) && !defined(UNIX)
    7982# include <windows.h>
    8083# include <direct.h>
    81 #endif
    82 
    83 #ifdef OS2
     84# define getcwd _getcwd
     85#endif
     86
     87#if defined(OS2)
    8488# define INCL_DOS
    8589# include <os2.h>
     90#endif
     91
     92#if defined(macintosh) && !defined(UNIX)
     93# include <unix.h>
     94# include <errno.h>
     95# include <unistd.h>
    8696#endif
    8797
     
    97107#endif
    98108
    99 #ifdef macintosh
    100 # include <unix.h>
    101 # include <errno.h>
    102 # include <unistd.h>
    103 #endif
    104109
    105110// -- TRUE FALSE
     
    166171finddirsep(const GUTF8String &fname)
    167172{
    168 #if defined(UNIX)
     173/* Lucide */
     174#if defined(WIN32) || defined(OS2)
     175  return fname.rcontains("\\/",0);
     176#elif defined(UNIX)
    169177  return fname.rsearch('/',0);
    170 #elif defined(WIN32) || defined(OS2)
    171   return fname.rcontains("\\/",0);
    172178#elif defined(macintosh)
    173179  return fname.rcontains(":/",0);
    174180#else
    175 #error "Define something here for your operating system"
     181# error "Define something here for your operating system"
    176182#endif 
    177183}
     
    343349  return GNativeString(string_buffer).getNative2UTF8();//MBCS cvt
    344350#else
    345 #error "Define something here for your operating system"
     351# error "Define something here for your operating system"
    346352#endif
    347353}
  • trunk/libdjvu/GOS.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GOS.h,v 1.9 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GOS.h,v 1.10 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GOS_H_
     
    8383    L\'eon Bottou <leonb@research.att.com> -- Initial implementation
    8484    @version
    85     #$Id: GOS.h,v 1.9 2007/03/25 20:48:32 leonb Exp $#
     85    #$Id: GOS.h,v 1.10 2008/01/27 11:36:27 leonb Exp $#
    8686*/
    8787//@{
     
    101101
    102102/** Operating System dependent functions. */
    103 class GOS
     103class DJVUAPI GOS
    104104{
    105105 public:
  • trunk/libdjvu/GPixmap.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GPixmap.cpp,v 1.16 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GPixmap.cpp,v 1.18 2009/02/18 07:26:25 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    569569            if (grey)
    570570              {
    571                 p[x].g = p[x].b = p[x].r = ramp[read_integer(lookahead, bs)];
     571                p[x].g = p[x].b = p[x].r = ramp[(int)read_integer(lookahead, bs)];
    572572              }
    573573            else
    574574              {
    575                 p[x].r = ramp[read_integer(lookahead, bs)];
    576                 p[x].g = ramp[read_integer(lookahead, bs)];
    577                 p[x].b = ramp[read_integer(lookahead, bs)];
     575                p[x].r = ramp[(int)read_integer(lookahead, bs)];
     576                p[x].g = ramp[(int)read_integer(lookahead, bs)];
     577                p[x].b = ramp[(int)read_integer(lookahead, bs)];
    578578              }
    579579        }
     
    10941094  while (x < dmax)             
    10951095  {
    1096     d[x] = s[smax];
     1096    d[x] = s[smax-1];
    10971097    x++;
    10981098  }
  • trunk/libdjvu/GPixmap.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GPixmap.h,v 1.9 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GPixmap.h,v 1.10 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GPIXMAP_H_
     
    8282    L\'eon Bottou <leonb@research.att.com>
    8383    @version
    84     #$Id: GPixmap.h,v 1.9 2007/03/25 20:48:32 leonb Exp $# */
     84    #$Id: GPixmap.h,v 1.10 2007/05/19 03:07:33 leonb Exp $# */
    8585//@{
    8686
     
    109109    pixel values represent an ink level.  */
    110110
    111 struct GPixel
     111struct DJVUAPI GPixel
    112112{
    113113  /** Blue component. */
     
    148148 */
    149149
    150 class GPixmap : public GPEnabled
     150class DJVUAPI GPixmap : public GPEnabled
    151151{
    152152protected:
  • trunk/libdjvu/GRect.cpp

    r206 r280  
    5555//
    5656// $Id: GRect.cpp,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/GRect.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GRect.h,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GRect.h,v 1.13 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GRECT_H_
     
    7878    L\'eon Bottou <leonb@research.att.com> -- initial implementation.
    7979    @version
    80     #$Id: GRect.h,v 1.12 2007/03/25 20:48:32 leonb Exp $# */
     80    #$Id: GRect.h,v 1.13 2007/05/19 03:07:33 leonb Exp $# */
    8181//@{
    8282
     
    139139    enclosing two rectangles (\Ref{recthull}).  */
    140140
    141 class GRect
     141class DJVUAPI GRect
    142142{
    143143public:
     
    211211    performed using integer fraction arithmetic in order to maximize
    212212    accuracy. */
    213 class GRectMapper
     213class DJVUAPI GRectMapper
    214214{
    215215public:
  • trunk/libdjvu/GScaler.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GScaler.h,v 1.11 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GScaler.h,v 1.12 2007/05/19 03:07:33 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GSCALER_H_
     
    101101    L\'eon Bottou <leonb@research.att.com>
    102102    @version
    103     #$Id: GScaler.h,v 1.11 2007/03/25 20:48:32 leonb Exp $# */
     103    #$Id: GScaler.h,v 1.12 2007/05/19 03:07:33 leonb Exp $# */
    104104//@{
    105105
     
    117117    \Ref{GPixmapScaler}. 
    118118*/
    119 class GScaler  : public GPEnabled
     119class DJVUAPI GScaler  : public GPEnabled
    120120{
    121121protected: 
     
    185185    }
    186186    \end{verbatim} */
    187 class GBitmapScaler : public GScaler
     187class DJVUAPI GBitmapScaler : public GScaler
    188188{
    189189protected:
     
    259259
    260260 */
    261 class GPixmapScaler : public GScaler
     261class DJVUAPI GPixmapScaler : public GScaler
    262262{
    263263protected:
  • trunk/libdjvu/GSmartPointer.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GSmartPointer.cpp,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GSmartPointer.cpp,v 1.26 2008/08/03 03:54:01 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    7272
    7373#include <string.h>
     74#if PARANOID_DEBUG
     75# include <assert.h>
     76#endif
     77
    7478#include "GThreads.h"
    7579#include "GSmartPointer.h"
    7680#include "GException.h"
    7781
    78 
    7982#ifdef HAVE_NAMESPACES
    8083namespace DJVU {
     
    8588
    8689
    87 // ------ STATIC CRITICAL SECTION
    88 
    89 static GCriticalSection gcsCounter;
    90 
    91 
    9290// ------ GPENABLED
    93 
    9491
    9592GPEnabled::~GPEnabled()
     
    10299GPEnabled::destroy()
    103100{
    104   if (count >= 0)
    105     G_THROW( ERR_MSG("GSmartPointer.suspicious") );
    106   delete this;
    107 }
    108 
    109 void
    110 GPEnabled::ref()
    111 {
    112   gcsCounter.lock();
    113   count++;
    114   gcsCounter.unlock();
    115 }
    116 
    117 void
    118 GPEnabled::unref()
    119 {
    120   gcsCounter.lock();
    121   if (! --count)
    122     count = -1;
    123   gcsCounter.unlock();
    124   if (count < 0)
    125     destroy();
     101  // Only delete if the counter is still zero.
     102  // because someone may have rescued the object...
     103  // If yes, set the counter to -0x7fff to mark
     104  // the object as doomed and make sure things
     105  // will work if the destructor uses a GP...
     106  if (atomicCompareAndSwap(&count, 0, -0x7fff))
     107    delete this;
    126108}
    127109
     
    129111// ------ GPBASE
    130112
     113
     114#define LOCKMASK 0x3f
     115#define LOCKIDX(addr) ((((size_t)(addr))/sizeof(void*))&LOCKMASK)
     116static int volatile locks[LOCKMASK+1];
     117
     118
     119GPBase&
     120GPBase::assign (const GPBase &sptr)
     121{
     122  int volatile *lockb = locks+LOCKIDX(&sptr);
     123  atomicAcquireOrSpin(lockb);
     124  GPEnabled *nptr = sptr.ptr;
     125  if (nptr)
     126    nptr->ref();
     127  atomicRelease(lockb);
     128  int volatile *locka = locks+LOCKIDX(this);
     129  atomicAcquireOrSpin(locka);
     130  GPEnabled *old = ptr;
     131  ptr = nptr;
     132  atomicRelease(locka);
     133  if (old)
     134    old->unref();
     135  return *this;
     136}
    131137
    132138GPBase&
    133139GPBase::assign (GPEnabled *nptr)
    134140{
    135   gcsCounter.lock();
    136141  if (nptr)
    137     {
    138       if (nptr->count >= 0) 
    139         nptr->count++;
    140       else
    141         nptr = 0;
    142     }
    143   if (ptr)
    144     {
    145       GPEnabled *old = ptr;
    146       ptr = nptr;
    147       if (! --old->count)
    148         old->count = -1;
    149       gcsCounter.unlock();     
    150       if (old->count < 0)
    151         old->destroy();
    152     }
    153   else
    154     {
    155       ptr = nptr;
    156       gcsCounter.unlock();
    157     }
     142    nptr->ref();
     143  int volatile *locka = locks+LOCKIDX(this);
     144  atomicAcquireOrSpin(locka);
     145  GPEnabled *old = ptr;
     146  ptr = nptr;
     147  atomicRelease(locka);
     148  if (old)
     149    old->unref();
    158150  return *this;
    159151}
    160152
    161 GPBase&
    162 GPBase::assign (const GPBase &sptr)
    163 {
    164   gcsCounter.lock();
    165   if (sptr.ptr)
    166     {
    167       sptr.ptr->count++;
    168     }
    169   if (ptr)
    170     {
    171       GPEnabled *old = ptr;
    172       ptr = sptr.ptr;
    173       if (! --old->count)
    174         old->count = -1;
    175       gcsCounter.unlock();     
    176       if (old->count < 0)
    177         old->destroy();
    178     }
    179   else
    180     {
    181       ptr = sptr.ptr;
    182       gcsCounter.unlock();
    183     }
    184   return *this;
    185 }
     153
    186154
    187155
  • trunk/libdjvu/GSmartPointer.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GSmartPointer.h,v 1.13 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GSmartPointer.h,v 1.16 2008/03/05 01:44:20 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GSMARTPOINTER_H_
     
    8989
    9090    @version
    91     #$Id: GSmartPointer.h,v 1.13 2007/03/25 20:48:32 leonb Exp $#
     91    #$Id: GSmartPointer.h,v 1.16 2008/03/05 01:44:20 leonb Exp $#
    9292    @args
    9393*/
     
    101101
    102102#include "DjVuGlobal.h"
     103#include "atomic.h"
    103104
    104105#ifdef HAVE_NAMESPACES
     
    116117    smart-pointers (see \Ref{GP}). 
    117118 */
    118 class GPEnabled
    119 {
     119class DJVUAPI GPEnabled
     120{
     121  friend class GPBase;
     122  void destroy();
     123  void unref();
     124  void ref();
    120125public:
    121126  /// Null constructor.
     
    133138  /// The reference counter
    134139  volatile int count;
    135 private:
    136   friend class GPBase;
    137   void unref();
    138   void ref();
    139   void destroy();
    140140};
    141141
     
    149149*/
    150150
    151 class GPBase
     151class DJVUAPI GPBase
    152152{
    153153public:
     
    206206    reference counter is incremented to one. Object destruction will then
    207207    happen automatically when the reference counter is decremented back to
    208     zero (i.e. when the last smart-pointer referencing this object stops doing so).
    209     This will happen regardless of how many regular pointers reference this object.
     208    zero (i.e. when the last smart-pointer referencing
     209    this object stops doing so).
     210    This will happen regardless of how many regular pointers
     211    reference this object.
    210212    In other words, if you start using smart-pointers with a #GPEnabled#
    211213    object, you engage automatic mode for this object.  You should only do
     
    333335}
    334336
     337inline void
     338GPEnabled::ref()
     339{
     340#if PARANOID_DEBUG
     341  assert (count >= 0);
     342#endif
     343  atomicIncrement(&count);
     344}
     345
     346inline void
     347GPEnabled::unref()
     348{
     349#if PARANOID_DEBUG
     350  assert (count > 0);
     351#endif
     352  if (! atomicDecrement(&count))
     353    destroy();
     354}
     355
    335356// INLINE FOR GPBASE
    336357
     
    368389GPBase::get() const
    369390{
     391#if PARANOID_DEBUG
     392  if (ptr && ptr->get_count() <= 0)
     393    *(int*)0=0;
     394#endif
    370395  return ptr;
    371396}
     
    414439GP<TYPE>::operator->() const
    415440{
     441#if PARANOID_DEBUG
     442  if (ptr && ptr->get_count() <= 0)
     443    *(int*)0=0;
     444#endif
    416445  return (TYPE*) ptr;
    417446}
     
    420449GP<TYPE>::operator*() const
    421450{
     451#if PARANOID_DEBUG
     452  if (ptr && ptr->get_count() <= 0)
     453    *(int*)0=0;
     454#endif
    422455  return *(TYPE*) ptr;
    423456}
     
    459492   What about the objects construction and destruction ? */
    460493
    461 class GPBufferBase
     494class DJVUAPI GPBufferBase
    462495{
    463496public:
  • trunk/libdjvu/GString.cpp

    r207 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GString.cpp,v 1.24 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GString.cpp,v 1.27 2009/05/17 23:57:42 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959// From: Leon Bottou, 1/31/2002
     
    204204GP<GStringRep>
    205205GStringRep::UTF8::create(
    206   const unsigned short *s,const int start,const int length)
     206  const uint16_t *s,const int start,const int length)
    207207{
    208208  GStringRep::UTF8 dummy;
     
    212212GP<GStringRep>
    213213GStringRep::UTF8::create(
    214   const unsigned long *s,const int start,const int length)
     214  const uint32_t *s,const int start,const int length)
    215215{
    216216  GStringRep::UTF8 dummy;
     
    337337    const char *s,const int start,const int length=(-1));
    338338  static GP<GStringRep> create(
    339     const unsigned short *s,const int start,const int length=(-1));
     339    const uint16_t *s,const int start,const int length=(-1));
    340340  static GP<GStringRep> create(
    341     const unsigned long *s,const int start,const int length=(-1));
     341    const uint32_t *s,const int start,const int length=(-1));
    342342
    343343    // Create with an sprintf()
     
    346346
    347347  virtual unsigned char *UCS4toString(
    348     const unsigned long w,unsigned char *ptr, mbstate_t *ps=0) const;
     348    const uint32_t w,unsigned char *ptr, mbstate_t *ps=0) const;
    349349
    350350  // Tests if a string is legally encoded in the current character set.
     
    356356protected:
    357357  // Return the next character and increment the source pointer.
    358   virtual unsigned long getValidUCS4(const char *&source) const;
     358  virtual uint32_t getValidUCS4(const char *&source) const;
    359359};
    360360
     
    411411GP<GStringRep>
    412412GStringRep::Native::create(
    413     const unsigned short *s,const int start,const int length)
     413    const uint16_t *s,const int start,const int length)
    414414{
    415415  GStringRep::Native dummy;
     
    419419GP<GStringRep>
    420420GStringRep::Native::create(
    421   const unsigned long *s,const int start,const int length)
     421  const uint32_t *s,const int start,const int length)
    422422{
    423423  GStringRep::Native dummy;
     
    533533unsigned char *
    534534GStringRep::Native::UCS4toString(
    535   const unsigned long w0,unsigned char *ptr, mbstate_t *ps) const
     535  const uint32_t w0,unsigned char *ptr, mbstate_t *ps) const
    536536{
    537537  return UCS4toNative(w0,ptr,ps);
     
    544544unsigned char *
    545545GStringRep::UCS4toNative(
    546   const unsigned long w0,unsigned char *ptr, mbstate_t *ps)
    547 {
    548   unsigned short w1;
    549   unsigned short w2=1;
     546  const uint32_t w0,unsigned char *ptr, mbstate_t *ps)
     547{
     548  uint16_t w1;
     549  uint16_t w2=1;
    550550  for(int count=(sizeof(wchar_t)==sizeof(w1)) ? UCS4toUTF16(w0,w1,w2) : 1;
    551551      count;
     
    589589    memset(&ps,0,sizeof(mbstate_t));
    590590    int i=0;
    591     if(sizeof(wchar_t) == sizeof(unsigned long))
     591    if(sizeof(wchar_t) == sizeof(uint32_t))
    592592      {
    593593        wchar_t w = 0;
    594594        for(;(n>0)&&((i=mbrtowc(&w,source,n,&ps))>=0); n-=i,source+=i)
    595595          {
    596             ptr=UCS4toUTF8(w,ptr);
     596            ptr=UCS4toUTF8((uint32_t)w,ptr);
    597597          }
    598598      }
     
    602602        for(;(n>0)&&((i=mbrtowc(&w,source,n,&ps))>=0);n-=i,source+=i)
    603603          {
    604             unsigned short s[2];
     604            uint16_t s[2];
    605605            s[0]=w;
    606             unsigned long w0;
     606            uint32_t w0;
    607607            if(UTF16toUCS4(w0,s,s+1)<=0)
    608608              {
     
    682682  if(slen>1)
    683683  {
    684 #ifndef OS2  // ER 
     684/* Lucide */
     685#ifndef OS2
    685686    retval=UTF8ToNative(false,escape) ;
    686687#endif
     
    830831}
    831832
    832 unsigned long
     833uint32_t
    833834GStringRep::Native::getValidUCS4(const char *&source) const
    834835{
    835   unsigned long retval=0;
     836  uint32_t retval=0;
    836837  int n=(int)((size_t)size+(size_t)data-(size_t)source);
    837838  if(source && (n > 0))
     
    844845    if(len>=0)
    845846    {
    846       if(sizeof(wchar_t) == sizeof(unsigned short))
     847      if(sizeof(wchar_t) == sizeof(uint16_t))
    847848      {
    848849        source+=len;
    849         unsigned short s[2];
    850         s[0]=(unsigned short)wt;
     850        uint16_t s[2];
     851        s[0]=(uint16_t)wt;
    851852        if(UTF16toUCS4(retval,s,s+1)<=0)
    852853        {
     
    856857            if(len>=0)
    857858            {
    858               s[1]=(unsigned short)wt;
    859               unsigned long w;
     859              s[1]=(uint16_t)wt;
     860              uint32_t w;
    860861              if(UTF16toUCS4(w,s,s+2)>0)
    861862              {
     
    868869      }else
    869870      {
    870         retval=(unsigned long)wt;
     871        retval=(uint32_t)wt;
    871872        source++;
    872873      }
     
    942943}
    943944
    944 GNativeString::GNativeString(const unsigned short *str)
     945GNativeString::GNativeString(const uint16_t *str)
    945946{
    946947  init(GStringRep::Native::create(str,0,-1));
    947948}
    948949
    949 GNativeString::GNativeString(const unsigned long *str)
     950GNativeString::GNativeString(const uint32_t *str)
    950951{
    951952  init(GStringRep::Native::create(str,0,-1));
     
    958959}
    959960
    960 GNativeString::GNativeString(const unsigned short *dat, unsigned int len)
     961GNativeString::GNativeString(const uint16_t *dat, unsigned int len)
    961962{
    962963  init(
     
    964965}
    965966
    966 GNativeString::GNativeString(const unsigned long *dat, unsigned int len)
     967GNativeString::GNativeString(const uint32_t *dat, unsigned int len)
    967968{
    968969  init(
     
    10971098
    10981099GP<GStringRep>
    1099 GStringRep::substr(const unsigned short *s,const int start,const int len) const
     1100GStringRep::substr(const uint16_t *s,const int start,const int len) const
    11001101{
    11011102  GP<GStringRep> retval;
    11021103  if(s && s[0])
    11031104  {
    1104     unsigned short const *eptr;
     1105    uint16_t const *eptr;
    11051106    if(len<0)
    11061107    {
     
    11201121      for(ptr=buf;s[0];)
    11211122      {
    1122         unsigned long w;
     1123        uint32_t w;
    11231124        int i=UTF16toUCS4(w,s,eptr);
    11241125        if(i<=0)
     
    11351136
    11361137GP<GStringRep>
    1137 GStringRep::substr(const unsigned long *s,const int start,const int len) const
     1138GStringRep::substr(const uint32_t *s,const int start,const int len) const
    11381139{
    11391140  GP<GStringRep> retval;
    11401141  if(s && s[0])
    11411142  {
    1142     unsigned long const *eptr;
     1143    uint32_t const *eptr;
    11431144    if(len<0)
    11441145    {
     
    12981299{
    12991300#if HAS_WCTYPE
    1300   return
    1301     ((sizeof(wchar_t) == 2)&&(w&~0xffff))
    1302     ||((unsigned long)iswspace((wchar_t)w))
    1303     ||((w == '\r')||(w == '\n'));
     1301  return iswspace((wchar_t)w);
    13041302#else
    1305   return
    1306     (w&~0xff)?(true):(((unsigned long)isspace((char)w))||((w == '\r')||(w == '\n')));
     1303  if (w & ~0xff) || isspace((int)(w & 0xff));
    13071304#endif
    13081305}
     
    13121309{
    13131310#if HAS_WCTYPE
    1314   return ((sizeof(wchar_t) == 2)&&(w&~0xffff))
    1315     ?(true):((unsigned long)iswupper((wchar_t)w)?true:false);
     1311  return iswupper((wchar_t)w);
    13161312#else
    1317   return (w&~0xff)?(true):((unsigned long)isupper((char)w)?true:false);
     1313  return (w & ~0xff) || isupper((int)(w & 0xff));
    13181314#endif
    13191315}
     
    13231319{
    13241320#if HAS_WCTYPE
    1325   return ((sizeof(wchar_t) == 2)&&(w&~0xffff))
    1326     ?(true):((unsigned long)iswlower((wchar_t)w)?true:false);
     1321  return iswlower((wchar_t)w);
    13271322#else
    1328   return (w&~0xff)?(true):((unsigned long)islower((char)w)?true:false);
     1323  return (w & ~0xff) || islower((int)(w & 0xff));
    13291324#endif
    13301325}
     
    13341329{
    13351330#if HAS_WCTYPE
    1336   return ((sizeof(wchar_t) == 2)&&(w&~0xffff))
    1337     ?w:((unsigned long)towupper((wchar_t)w));
     1331  return (unsigned long)towupper((wchar_t)w);
    13381332#else
    1339   return (w&~0xff)?w:((unsigned long)toupper((char)w));
     1333  return (w&~0xff) ? w : (unsigned long)toupper(w & 0xff);
    13401334#endif
    13411335}
     
    13451339{
    13461340#if HAS_WCTYPE
    1347   return ((sizeof(wchar_t) == 2)&&(w&~0xffff))
    1348     ?w:((unsigned long)towlower((wchar_t)w));
     1341  return (unsigned long)towlower((wchar_t)w);
    13491342#else
    1350   return (w&~0xff)?w:((unsigned long)tolower((char)w));
     1343  return (w&~0xff) ? w : (unsigned long)tolower(w & 0xff);
    13511344#endif
    13521345}
     
    16061599}
    16071600
    1608 #ifdef WIN32
    1609 #define USE_VSNPRINTF _vsnprintf
    1610 #endif
    1611 
    1612 #ifdef AUTOCONF
    1613 # ifdef HAVE_VSNPRINTF
    1614 #  define USE_VSNPRINTF vsnprintf
    1615 # endif
    1616 #else
    1617 # ifdef linux
    1618 #  define USE_VSNPRINTF vsnprintf
    1619 # endif
    1620 #endif
    1621 
     1601#if defined(AUTOCONF) && defined(HAVE_VSNPRINTF)
     1602# define USE_VSNPRINTF vsnprintf
     1603#elif defined(WIN32) && !defined(__CYGWIN32__)
     1604# define USE_VSNPRINTF _vsnprintf
     1605#elif defined(linux)
     1606# define USE_VSNPRINTF vsnprintf
     1607#endif
     1608 
    16221609GUTF8String &
    16231610GUTF8String::format(const char fmt[], ... )
     
    16421629  if(size)
    16431630  {
    1644 #ifndef WIN32
    1645     char *nfmt;
    1646     GPBuffer<char> gnfmt(nfmt,size+1);
    1647     nfmt[0]=0;
    1648     int start=0;
    1649 #endif
    1650     int from=0;
    1651     while((from=search('%',from)) >= 0)
    1652     {
    1653       if(data[++from] != '%')
    1654       {
    1655         int m,n=0;
    1656         sscanf(data+from,"%d!%n",&m,&n);
    1657         if(n)
    1658         {
    1659 #ifdef WIN32
    1660           char *lpszFormat=data;
    1661           LPTSTR lpszTemp;
    1662           if((!::FormatMessage(
    1663             FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
    1664               lpszFormat, 0, 0, (LPTSTR)&lpszTemp,0,&args))
    1665             || !lpszTemp)
    1666           {
    1667             G_THROW(GException::outofmemory);
    1668           }
    1669           va_end(args);
    1670           retval=strdup((const char *)lpszTemp);
    1671           LocalFree(lpszTemp);
    1672           break;
    1673 #else
    1674           from+=n;
    1675           const int end=search('!',from);
    1676           if(end>=0)
    1677           {
    1678             strncat(nfmt,data+start,(int)(end-start));
    1679             strncat(nfmt,"$",1);
    1680             start=from=end+1;
    1681           }else
    1682           {
    1683             gnfmt.resize(0);
    1684             from=(-1);
    1685             break;
    1686           }
    1687 #endif
    1688         }else
    1689         {
    1690 #ifndef WIN32
    1691           gnfmt.resize(0);
    1692 #endif
    1693           from=(-1);
    1694           break;
    1695         }
    1696       }
    1697     }
    1698     if(from < 0)
    1699     {
    1700 #ifndef WIN32
    1701       char const * const fmt=(nfmt&&nfmt[0])?nfmt:data;
    1702 #else
    1703       char const * const fmt=data;
    1704 #endif
    1705       int buflen=32768;
    1706       char *buffer;
    1707       GPBuffer<char> gbuffer(buffer,buflen);
    1708 
    1709       ChangeLocale locale(LC_NUMERIC,(isNative()?0:"C"));
    1710 
    1711       // Format string
     1631    char const * const fmt=data;
     1632    int buflen=32768;
     1633    char *buffer;
     1634    GPBuffer<char> gbuffer(buffer,buflen);
     1635    ChangeLocale locale(LC_NUMERIC,(isNative()?0:"C"));
     1636    // Format string
    17121637#ifdef USE_VSNPRINTF
    1713       while(USE_VSNPRINTF(buffer, buflen, fmt, args)<0)
     1638    while(USE_VSNPRINTF(buffer, buflen, fmt, args)<0)
    17141639      {
    17151640        gbuffer.resize(0);
    17161641        gbuffer.resize(buflen+32768);
    17171642      }
    1718       va_end(args);
     1643    va_end(args);
    17191644#else
    1720       buffer[buflen-1] = 0;
    1721       vsprintf(buffer, fmt, args);
    1722       va_end(args);
    1723       if (buffer[buflen-1])
     1645    buffer[buflen-1] = 0;
     1646    vsprintf(buffer, fmt, args);
     1647    va_end(args);
     1648    if (buffer[buflen-1])
    17241649      {
    17251650        // This isn't as fatal since it is on the stack, but we
     
    17281653      }
    17291654#endif
    1730       retval=strdup((const char *)buffer);
    1731     }
     1655    retval=strdup((const char *)buffer);
    17321656  }
    17331657  // Go altering the string
     
    18861810unsigned char *
    18871811GStringRep::UTF8::UCS4toString(
    1888   const unsigned long w0,unsigned char *ptr, mbstate_t *) const
     1812  const uint32_t w0,unsigned char *ptr, mbstate_t *) const
    18891813{
    18901814  return UCS4toUTF8(w0,ptr);
     
    19071831      for(const unsigned char *s=(const unsigned char *)data;(r<rend)&&(s<eptr)&&*s;)
    19081832          {
    1909         const unsigned long w0=UTF8toUCS4(s,eptr);
    1910         unsigned short w1;
    1911         unsigned short w2=1;
     1833        const uint32_t w0=UTF8toUCS4(s,eptr);
     1834        uint16_t w1;
     1835        uint16_t w2=1;
    19121836        for(int count=(sizeof(wchar_t) == sizeof(w1))?UCS4toUTF16(w0,w1,w2):1;
    19131837            count&&(r<rend);
     
    19451869    for(const unsigned char *s=(const unsigned char *)data;(s<eptr)&& *s;)
    19461870    {
    1947       const unsigned long w0=UTF8toUCS4(s,eptr);
     1871      const uint32_t w0=UTF8toUCS4(s,eptr);
    19481872      const unsigned char * const r0=r;
    19491873      r=UCS4toNative(w0,r,&ps);
     
    19521876        if(escape == IS_ESCAPED)
    19531877        {
    1954           sprintf((char *)r,"&#%lu;",w0);
     1878          sprintf((char *)r,"&#%lu;",(unsigned long)w0);
    19551879          r+=strlen((char *)r);
    19561880        }else
     
    20001924}
    20011925
    2002 static inline unsigned long
    2003 add_char(unsigned long const U, unsigned char const * const r)
    2004 {
    2005   unsigned long const C=r[0];
     1926static inline uint32_t
     1927add_char(uint32_t const U, unsigned char const * const r)
     1928{
     1929  uint32_t const C=r[0];
    20061930  return ((C|0x3f) == 0xbf)?((U<<6)|(C&0x3f)):0;
    20071931}
    20081932
    2009 unsigned long
     1933uint32_t
    20101934GStringRep::UTF8toUCS4(
    20111935  unsigned char const *&s,void const * const eptr)
    20121936{
    2013   unsigned long U=0;
     1937  uint32_t U=0;
    20141938  unsigned char const *r=s;
    20151939  if(r < eptr)
    20161940  {
    2017     unsigned long const C1=r++[0];
     1941    uint32_t const C1=r++[0];
    20181942    if(C1&0x80)
    20191943    {
     
    21132037
    21142038unsigned char *
    2115 GStringRep::UCS4toUTF8(const unsigned long w,unsigned char *ptr)
     2039GStringRep::UCS4toUTF8(const uint32_t w,unsigned char *ptr)
    21162040{
    21172041  if(w <= 0x7f)
     
    22402164  return locale;
    22412165}
     2166const char *setlocale_win32_var = setlocale_win32();
    22422167#endif
    22432168
    22442169GStringRep::GStringRep(void)
    22452170{
    2246 #ifdef WIN32
    2247   static const char *locale=setlocale_win32();
    2248 #endif
    22492171  size=0;
    22502172  data=0;
     
    24752397
    24762398int
    2477 GStringRep::getUCS4(unsigned long &w, const int from) const
     2399GStringRep::getUCS4(uint32_t &w, const int from) const
    24782400{
    24792401  int retval;
     
    24962418
    24972419
    2498 unsigned long
     2420uint32_t
    24992421GStringRep::UTF8::getValidUCS4(const char *&source) const
    25002422{
     
    25502472int
    25512473GStringRep::UCS4toUTF16(
    2552   const unsigned long w,unsigned short &w1, unsigned short &w2)
     2474  const uint32_t w,uint16_t &w1, uint16_t &w2)
    25532475{
    25542476  int retval;
    25552477  if(w<0x10000)
    25562478  {
    2557     w1=(unsigned short)w;
     2479    w1=(uint16_t)w;
    25582480    w2=0;
    25592481    retval=1;
    25602482  }else
    25612483  {
    2562     w1=(unsigned short)((((w-0x10000)>>10)&0x3ff)+0xD800);
    2563     w2=(unsigned short)((w&0x3ff)+0xDC00);
     2484    w1=(uint16_t)((((w-0x10000)>>10)&0x3ff)+0xD800);
     2485    w2=(uint16_t)((w&0x3ff)+0xDC00);
    25642486    retval=2;
    25652487  }
     
    25692491int
    25702492GStringRep::UTF16toUCS4(
    2571   unsigned long &U,unsigned short const * const s,void const * const eptr)
     2493  uint32_t &U,uint16_t const * const s,void const * const eptr)
    25722494{
    25732495  int retval=0;
    25742496  U=0;
    2575   unsigned short const * const r=s+1;
     2497  uint16_t const * const r=s+1;
    25762498  if(r <= eptr)
    25772499  {
    2578     unsigned long const W1=s[0];
     2500    uint32_t const W1=s[0];
    25792501    if((W1<0xD800)||(W1>0xDFFF))
    25802502    {
     
    25852507    }else if(W1<=0xDBFF)
    25862508    {
    2587       unsigned short const * const rr=r+1;
     2509      uint16_t const * const rr=r+1;
    25882510      if(rr <= eptr)
    25892511      {
    2590         unsigned long const W2=s[1];
     2512        uint32_t const W2=s[1];
    25912513        if(((W2>=0xDC00)||(W2<=0xDFFF))&&((U=(0x10000+((W1&0x3ff)<<10))|(W2&0x3ff))))
    25922514        {
     
    26882610{ init(GStringRep::UTF8::create((const char *)str)); }
    26892611
    2690 GUTF8String::GUTF8String(const unsigned short *str)
     2612GUTF8String::GUTF8String(const uint16_t *str)
    26912613{ init(GStringRep::UTF8::create(str,0,-1)); }
    26922614
    2693 GUTF8String::GUTF8String(const unsigned long *str)
     2615GUTF8String::GUTF8String(const uint32_t *str)
    26942616{ init(GStringRep::UTF8::create(str,0,-1)); }
    26952617
     
    26972619{ init(GStringRep::UTF8::create(dat,0,((int)len<0)?(-1):(int)len)); }
    26982620
    2699 GUTF8String::GUTF8String(const unsigned short *dat, unsigned int len)
     2621GUTF8String::GUTF8String(const uint16_t *dat, unsigned int len)
    27002622{ init(GStringRep::UTF8::create(dat,0,((int)len<0)?(-1):(int)len)); }
    27012623
    2702 GUTF8String::GUTF8String(const unsigned long *dat, unsigned int len)
     2624GUTF8String::GUTF8String(const uint32_t *dat, unsigned int len)
    27032625{ init(GStringRep::UTF8::create(dat,0,((int)len<0)?(-1):(int)len)); }
    27042626
  • trunk/libdjvu/GString.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GString.h,v 1.21 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GString.h,v 1.25 2009/05/17 23:57:42 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GSTRING_H_
     
    106106   
    107107    @version
    108     #$Id: GString.h,v 1.21 2007/03/25 20:48:32 leonb Exp $# */
     108    #$Id: GString.h,v 1.25 2009/05/17 23:57:42 leonb Exp $# */
    109109//@{
    110110
     
    127127#endif
    128128
     129#if !defined(AUTOCONF) || HAVE_STDINT_H
     130# include <stdint.h>
     131#elif HAVE_INTTYPES_H
     132# include <inttypes.h>
     133#endif
    129134
    130135#ifdef HAVE_NAMESPACES
     
    146151
    147152// Internal string representation.
    148 class GStringRep : public GPEnabled
     153class DJVUAPI GStringRep : public GPEnabled
    149154{
    150155public:
     
    167172  friend class GUTF8String;
    168173  friend class GNativeString;
    169   friend unsigned int hash(const GBaseString &ref);
     174  friend DJVUAPI unsigned int hash(const GBaseString &ref);
    170175
    171176public:
     
    241246
    242247  GP<GStringRep> substr(
    243     const unsigned short *s,const int start,const int length=(-1)) const;
     248    const uint16_t *s,const int start,const int length=(-1)) const;
    244249
    245250  GP<GStringRep> substr(
    246     const unsigned long *s,const int start,const int length=(-1)) const;
     251    const uint32_t *s,const int start,const int length=(-1)) const;
    247252
    248253  /** Initializes a string with a formatted string (as in #vprintf#).  The
     
    265270
    266271  /** Returns the next UCS4 character, and updates the pointer s. */
    267   static unsigned long UTF8toUCS4(
     272  static uint32_t UTF8toUCS4(
    268273    unsigned char const *&s, void const * const endptr );
    269274
     
    271276      and sets #w# to the next UCS4 chacter.  */
    272277  static int UTF8toUCS4(
    273     unsigned long &w, unsigned char const s[], void const * const endptr )
     278    uint32_t &w, unsigned char const s[], void const * const endptr )
    274279  { unsigned char const *r=s;w=UTF8toUCS4(r,endptr);return (int)((size_t)r-(size_t)s); }
    275280
    276281  /** Returns the next UCS4 word from the UTF16 string. */
    277282  static int UTF16toUCS4(
    278      unsigned long &w, unsigned short const * const s,void const * const eptr);
     283     uint32_t &w, uint16_t const * const s,void const * const eptr);
    279284
    280285  static int UCS4toUTF16(
    281     unsigned long w, unsigned short &w1, unsigned short &w2);
     286    uint32_t w, uint16_t &w1, uint16_t &w2);
    282287
    283288  int cmp(const char *s2, const int len=(-1)) const;
     
    292297
    293298  // Lookup the next character, and return the position of the next character.
    294   int getUCS4(unsigned long &w, const int from) const;
     299  int getUCS4(uint32_t &w, const int from) const;
    295300
    296301  virtual unsigned char *UCS4toString(
    297     const unsigned long w, unsigned char *ptr, mbstate_t *ps=0) const = 0;
     302    const uint32_t w, unsigned char *ptr, mbstate_t *ps=0) const = 0;
    298303
    299304  static unsigned char *UCS4toUTF8(
    300     const unsigned long w,unsigned char *ptr);
     305    const uint32_t w,unsigned char *ptr);
    301306
    302307  static unsigned char *UCS4toNative(
    303     const unsigned long w,unsigned char *ptr, mbstate_t *ps);
     308    const uint32_t w,unsigned char *ptr, mbstate_t *ps);
    304309
    305310  int search(char c, int from=0) const;
     
    317322protected:
    318323  // Return the next character and increment the source pointer.
    319   virtual unsigned long getValidUCS4(const char *&source) const = 0;
     324  virtual uint32_t getValidUCS4(const char *&source) const = 0;
    320325
    321326  GP<GStringRep> tocase(
     
    357362  // Tests if a string is legally encoded in the current character set.
    358363  virtual bool is_valid(void) const = 0;
    359 
     364#if HAS_WCHAR
    360365  virtual int ncopy(wchar_t * const buf, const int buflen) const = 0;
    361 
     366#endif
    362367protected:
    363368
     
    367372};
    368373
    369 class GStringRep::UTF8 : public GStringRep
     374class DJVUAPI GStringRep::UTF8 : public GStringRep
    370375{
    371376public:
     
    417422
    418423  static GP<GStringRep> create(
    419     const unsigned short *s,const int start,const int length=(-1));
     424    const uint16_t *s,const int start,const int length=(-1));
    420425
    421426  static GP<GStringRep> create(
    422     const unsigned long *s,const int start,const int length=(-1));
     427    const uint32_t *s,const int start,const int length=(-1));
    423428
    424429  static GP<GStringRep> create_format(const char fmt[],...);
     
    426431
    427432  virtual unsigned char *UCS4toString(
    428     const unsigned long w,unsigned char *ptr, mbstate_t *ps=0) const;
     433    const uint32_t w,unsigned char *ptr, mbstate_t *ps=0) const;
    429434
    430435  // Tests if a string is legally encoded in the current character set.
    431436  virtual bool is_valid(void) const;
    432 
     437#if HAS_WCHAR
    433438  virtual int ncopy(wchar_t * const buf, const int buflen) const;
    434 
     439#endif
    435440  friend class GBaseString;
    436441
    437442protected:
    438443  // Return the next character and increment the source pointer.
    439   virtual unsigned long getValidUCS4(const char *&source) const;
     444  virtual uint32_t getValidUCS4(const char *&source) const;
    440445};
    441446
     
    464469    position #-2# represents the second last character, etc.)  */
    465470
    466 class GBaseString : protected GP<GStringRep>
     471class DJVUAPI GBaseString : protected GP<GStringRep>
    467472{
    468473public:
     
    476481protected:
    477482  // Sets the gstr pointer;
    478   void init(void);
     483  inline void init(void);
    479484
    480485  ~GBaseString();
    481   GBaseString &init(const GP<GStringRep> &rep);
     486  inline GBaseString &init(const GP<GStringRep> &rep);
    482487
    483488  // -- CONSTRUCTORS
     
    680685      range by computing its remainder modulo the upper bound of
    681686      the range. */
    682   friend unsigned int hash(const GBaseString &ref);
     687  friend DJVUAPI unsigned int hash(const GBaseString &ref);
    683688  // -- HELPERS
    684689  friend class GStringRep;
     
    700705
    701706  /// copy to a wchar_t buffer
     707#if HAS_WCHAR
    702708  int ncopy(wchar_t * const buf, const int buflen) const;
    703 
     709#endif
    704710protected:
    705711  const char *gstr;
     
    712718  GUTF8String NativeToUTF8(void) const;
    713719protected:
    714   int CheckSubscript(int n) const;
     720  inline int CheckSubscript(int n) const;
    715721};
    716722
     
    736742    position #-2# represents the second last character, etc.)  */
    737743
    738 class GUTF8String : public GBaseString
     744class DJVUAPI GUTF8String : public GBaseString
    739745{
    740746public:
    741747  ~GUTF8String();
    742   void init(void);
    743 
    744   GUTF8String &init(const GP<GStringRep> &rep);
     748  inline void init(void);
     749
     750  inline GUTF8String &init(const GP<GStringRep> &rep);
    745751
    746752  // -- CONSTRUCTORS
     
    753759  /// Constructs a string from a null terminated character array.
    754760  GUTF8String(const unsigned char *str);
    755   GUTF8String(const unsigned short *dat);
    756   GUTF8String(const unsigned long *dat);
     761  GUTF8String(const uint16_t *dat);
     762  GUTF8String(const uint32_t *dat);
    757763  /** Constructs a string from a character array.  Elements of the
    758764      character array #dat# are added into the string until the
     
    760766      character (whichever comes first). */
    761767  GUTF8String(const char *dat, unsigned int len);
    762   GUTF8String(const unsigned short *dat, unsigned int len);
    763   GUTF8String(const unsigned long *dat, unsigned int len);
     768  GUTF8String(const uint16_t *dat, unsigned int len);
     769  GUTF8String(const uint32_t *dat, unsigned int len);
    764770
    765771  /// Construct from base class.
     
    779785  GUTF8String& operator= (const char str);
    780786  GUTF8String& operator= (const char *str);
    781   GUTF8String& operator= (const GP<GStringRep> &str);
    782   GUTF8String& operator= (const GBaseString &str);
    783   GUTF8String& operator= (const GUTF8String &str);
    784   GUTF8String& operator= (const GNativeString &str);
     787  inline GUTF8String& operator= (const GP<GStringRep> &str);
     788  inline GUTF8String& operator= (const GBaseString &str);
     789  inline GUTF8String& operator= (const GUTF8String &str);
     790  inline GUTF8String& operator= (const GNativeString &str);
    785791
    786792  /** Constructs a string with a formatted string (as in #vprintf#).
     
    874880  GUTF8String operator+(const GUTF8String &s2) const;
    875881  GUTF8String operator+(const GNativeString &s2) const;
    876   GUTF8String operator+(const char    *s2) const;
    877   friend GUTF8String operator+(const char    *s1, const GUTF8String &s2);
     882  GUTF8String operator+(const char *s2) const;
     883  friend DJVUAPI GUTF8String operator+(const char *s1, const GUTF8String &s2);
    878884
    879885  /** Provides a direct access to the string buffer.  Returns a
     
    908914  GP<GStringRep::Unicode> get_remainder(void) const;
    909915  static GUTF8String create( const char *buf, const unsigned int bufsize );
    910   static GUTF8String create( const unsigned short *buf, const unsigned int bufsize );
    911   static GUTF8String create( const unsigned long *buf, const unsigned int bufsize );
     916  static GUTF8String create( const uint16_t *buf, const unsigned int bufsize );
     917  static GUTF8String create( const uint32_t *buf, const unsigned int bufsize );
    912918};
    913919
     
    938944    position #-2# represents the second last character, etc.)  */
    939945
    940 class GNativeString : public GBaseString
     946class DJVUAPI GNativeString : public GBaseString
    941947{
    942948public:
     
    951957  /// Constructs a string from a null terminated character array.
    952958  GNativeString(const unsigned char *str);
    953   GNativeString(const unsigned short *str);
    954   GNativeString(const unsigned long *str);
     959  GNativeString(const uint16_t *str);
     960  GNativeString(const uint32_t *str);
    955961  /** Constructs a string from a character array.  Elements of the
    956962      character array #dat# are added into the string until the
     
    958964      character (whichever comes first). */
    959965  GNativeString(const char *dat, unsigned int len);
    960   GNativeString(const unsigned short *dat, unsigned int len);
    961   GNativeString(const unsigned long *dat, unsigned int len);
     966  GNativeString(const uint16_t *dat, unsigned int len);
     967  GNativeString(const uint32_t *dat, unsigned int len);
    962968  /// Construct from base class.
    963969  GNativeString(const GP<GStringRep> &str);
     
    10061012  GNativeString& operator= (const char str);
    10071013  GNativeString& operator= (const char *str);
    1008   GNativeString& operator= (const GP<GStringRep> &str);
    1009   GNativeString& operator= (const GBaseString &str);
    1010   GNativeString& operator= (const GUTF8String &str);
    1011   GNativeString& operator= (const GNativeString &str);
     1014  inline GNativeString& operator= (const GP<GStringRep> &str);
     1015  inline GNativeString& operator= (const GBaseString &str);
     1016  inline GNativeString& operator= (const GUTF8String &str);
     1017  inline GNativeString& operator= (const GNativeString &str);
    10121018  // -- CONCATENATION
    10131019  /// Appends character #ch# to the string.
     
    10381044  GUTF8String operator+(const GUTF8String &s2) const;
    10391045  GNativeString operator+(const char *s2) const;
    1040   friend GNativeString operator+(const char *s1, const GNativeString &s2);
     1046  friend DJVUAPI GNativeString operator+(const char *s1, const GNativeString &s2);
    10411047
    10421048  /** Initializes a string with a formatted string (as in #printf#).
     
    10861092
    10871093  static GNativeString create( const char *buf, const unsigned int bufsize );
    1088   static GNativeString create( const unsigned short *buf, const unsigned int bufsize );
    1089   static GNativeString create( const unsigned long *buf, const unsigned int bufsize );
     1094  static GNativeString create( const uint16_t *buf, const unsigned int bufsize );
     1095  static GNativeString create( const uint32_t *buf, const unsigned int bufsize );
    10901096#endif // WinCE
    10911097};
     
    13921398{ return ptr?((*this)->is_valid()):true; }
    13931399
     1400#if HAS_WCHAR
    13941401inline int
    13951402GBaseString::ncopy(wchar_t * const buf, const int buflen) const
    13961403{if(buf&&buflen)buf[0]=0;return ptr?((*this)->ncopy(buf,buflen)):0;}
     1404#endif
    13971405
    13981406inline int
     
    14391447
    14401448inline GUTF8String
    1441 GUTF8String::create( const unsigned short *buf, const unsigned int bufsize )
     1449GUTF8String::create( const uint16_t *buf, const unsigned int bufsize )
    14421450{
    14431451  return GUTF8String(buf,bufsize);
     
    14451453
    14461454inline GUTF8String
    1447 GUTF8String::create( const unsigned long *buf, const unsigned int bufsize )
     1455GUTF8String::create( const uint32_t *buf, const unsigned int bufsize )
    14481456{
    14491457  return GUTF8String(buf,bufsize);
     
    14761484
    14771485inline
    1478 GNativeString::GNativeString(const unsigned short *str)
     1486GNativeString::GNativeString(const uint16_t *str)
    14791487: GUTF8String(str) {}
    14801488
    14811489inline
    1482 GNativeString::GNativeString(const unsigned long *str)
     1490GNativeString::GNativeString(const uint32_t *str)
    14831491: GUTF8String(str) {}
    14841492
     
    14881496
    14891497inline
    1490 GNativeString::GNativeString(const unsigned short *dat, unsigned int len)
     1498GNativeString::GNativeString(const uint16_t *dat, unsigned int len)
    14911499: GUTF8String(dat,len) {}
    14921500
    14931501inline
    1494 GNativeString::GNativeString(const unsigned long *dat, unsigned int len)
     1502GNativeString::GNativeString(const uint32_t *dat, unsigned int len)
    14951503: GUTF8String(dat,len) {}
    14961504
     
    15831591
    15841592inline GNativeString
    1585 GNativeString::create( const unsigned short *buf, const unsigned int bufsize )
     1593GNativeString::create( const uint16_t *buf, const unsigned int bufsize )
    15861594{
    15871595  return GNativeString(buf,bufsize);
     
    15891597
    15901598inline GNativeString
    1591 GNativeString::create( const unsigned long *buf, const unsigned int bufsize )
     1599GNativeString::create( const uint32_t *buf, const unsigned int bufsize )
    15921600{
    15931601  return GNativeString(buf,bufsize);
  • trunk/libdjvu/GThreads.cpp

    r206 r280  
    5555//
    5656// $Id: GThreads.cpp,v 1.19 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/GThreads.h

    r206 r280  
    5555//
    5656// $Id: GThreads.h,v 1.11 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GTHREADS_H_
  • trunk/libdjvu/GURL.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GURL.cpp,v 1.24 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GURL.cpp,v 1.29 2008/01/27 16:16:26 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    8383
    8484#ifdef WIN32
    85 # include <atlbase.h>
     85# include <tchar.h>
    8686# include <windows.h>
    8787# include <direct.h>
     
    162162#endif
    163163
     164/* Lucide */
    164165#ifdef OS2
    165166#define _tcsrchr strrchr
     
    487488GURL::protocol(const GUTF8String& url)
    488489{
    489    const char * const url_ptr=url;
    490    const char * ptr=url_ptr;
    491    for(char c=*ptr;
    492      c && (isalnum(c) || c == '+' || c == '-' || c == '.');
    493      c=*(++ptr)) EMPTY_LOOP;
    494    return(*ptr==colon)?GUTF8String(url_ptr, ptr-url_ptr):GUTF8String();
     490  const char * const url_ptr=url;
     491  const char * ptr=url_ptr;
     492  for(char c=*ptr;
     493      c && (isalnum(c) || c == '+' || c == '-' || c == '.');
     494      c=*(++ptr)) EMPTY_LOOP;
     495  if (ptr[0]==colon && ptr[1]=='/' && ptr[2]=='/')
     496    return GUTF8String(url_ptr, ptr-url_ptr);
     497  return GUTF8String();
    495498}
    496499
     
    11031106         (ss>='A' && ss<='Z') ||
    11041107         (ss>='0' && ss<='9') ||
    1105          (strchr("$-_.+!*'(),:~=", ss)) )
     1108         (strchr("$-_.+!*'(),~:=", ss)) )
    11061109    {
    11071110      *d = ss;
     
    14171420    dwAttrib = GetFileAttributesW(wfilename);
    14181421    if((dwAttrib|1) == 0xFFFFFFFF)
    1419       {
    1420         USES_CONVERSION ;
    1421         dwAttrib = GetFileAttributes(A2CT(NativeFilename())) ;//MBCS cvt
    1422       }
     1422        dwAttrib = GetFileAttributesA(NativeFilename());
    14231423    retval=!( dwAttrib & FILE_ATTRIBUTE_DIRECTORY );
    14241424#else
     
    14541454    dwAttrib = GetFileAttributesW(wfilename);
    14551455    if((dwAttrib|1) == 0xFFFFFFFF)
    1456       {
    1457         USES_CONVERSION ;
    1458         dwAttrib = GetFileAttributes(A2CT(NativeFilename())) ;//MBCS cvt
    1459       }
     1456        dwAttrib = GetFileAttributesA(NativeFilename());
    14601457    retval=( (dwAttrib|1) != 0xFFFFFFFF);
    14611458#endif
     
    14951492    dwAttrib = GetFileAttributesW(wfilename);
    14961493    if((dwAttrib|1) == 0xFFFFFFFF)
    1497       {
    1498         USES_CONVERSION ;
    1499         dwAttrib = GetFileAttributes(A2CT(NativeFilename())) ;//MBCS cvt
    1500       }
     1494        dwAttrib = GetFileAttributesA(NativeFilename());
    15011495    retval=((dwAttrib != 0xFFFFFFFF)&&( dwAttrib & FILE_ATTRIBUTE_DIRECTORY ));
    15021496#else
     
    15411535  if(!retval)
    15421536    {
     1537/* Lucide */
    15431538#if defined(UNIX) || defined(OS2)
    15441539      if (is_dir())
     
    15471542        retval = ::mkdir(NativeFilename(), 0755);
    15481543#elif defined(WIN32)
    1549       USES_CONVERSION;
    15501544      if (is_dir())
    15511545        retval = 0;
    15521546      else
    1553         retval = CreateDirectory(A2CT(NativeFilename()), NULL);
     1547        retval = CreateDirectoryA(NativeFilename(), NULL);
    15541548#else
    15551549# error "Define something here for your operating system"
     
    15681562  if(is_local_file_url())
    15691563    {
     1564/* Lucide */
    15701565#if defined(UNIX) || defined(OS2)
    15711566      if (is_dir())
     
    15741569        retval = ::unlink(NativeFilename());
    15751570#elif defined(WIN32)
    1576       USES_CONVERSION;
    15771571      if (is_dir())
    1578         retval = ::RemoveDirectory(A2CT(NativeFilename()));
     1572        retval = ::RemoveDirectoryA(NativeFilename());
    15791573      else
    1580         retval = ::DeleteFile(A2CT(NativeFilename()));
     1574        retval = ::DeleteFile(NativeFilename());
    15811575#else
    15821576# error "Define something here for your operating system"
     
    17701764    *s = 0;
    17711765  }
    1772 #elif defined(WIN32) || defined(OS2) // WIN32 implementation (ER: and OS/2)
     1766/* Lucide */
     1767#elif defined (WIN32) || defined(OS2) // WIN32 implementation
    17731768  // Handle base
    17741769  strcpy(string_buffer, (char const *)(from ? expand_name(from) : GOS::cwd()));
     
    18081803          drv[2]= dot ;
    18091804          drv[3]=0;
    1810           // !!! ER todo !!! GetFullPathName(drv, maxlen, string_buffer, &s);
     1805/* Lucide */ /* ToDo */
     1806          // GetFullPathName(drv, maxlen, string_buffer, &s);
    18111807          strcpy(string_buffer,(const char *)GUTF8String(string_buffer).getNative2UTF8());
    18121808          s = string_buffer;
     
    18301826    }
    18311827    // Process path components
    1832     for(;*fname== slash || *fname==backslash;fname++)
    1833       EMPTY_LOOP;
    18341828    while(*fname)
    18351829    {
     1830      for(;*fname== slash || *fname==backslash;fname++)
     1831        EMPTY_LOOP;
    18361832      if (fname[0]== dot )
    18371833      {
     
    18401836          fname++;
    18411837          continue;
    1842         }else if ((fname[1] == dot)
    1843           && (fname[2]== slash || fname[2]==backslash || !fname[2]))
     1838        }
     1839                else if ((fname[1] == dot)
     1840                 && (fname[2]== slash || fname[2]==backslash || !fname[2]))
    18441841        {
    18451842          fname += 2;
     
    18561853          continue;
    18571854        }
    1858         char* s2=s;//MBCS DBCS
    1859         for(;*s;s++)
    1860           EMPTY_LOOP;
    1861         char* back = _tcsrchr(s2,backslash);//MBCS DBCS
    1862         if ((s>string_buffer)&&(*(s-1)!= slash)&&
    1863             (back == NULL || (back!=NULL && s-1 != back) ))//MBCS DBCS
    1864         {
    1865           *s = backslash;
    1866           s++;
    1867         }
    1868         while (*fname && *fname!= slash && *fname!=backslash)
    1869         {
    1870           *s = *fname++;
    1871           if ((size_t)((++s)-string_buffer) > maxlen)
    1872             G_THROW( ERR_MSG("GURL.big_name") );
    1873         }
    1874         *s = 0;
    18751855      }
    18761856      char* s2=s;//MBCS DBCS
    18771857      for(;*s;s++)
    18781858        EMPTY_LOOP;
    1879       char* back = _tcsrchr(s2,backslash);//MBCS DBCS
    1880       if ((s>string_buffer)&&(*(s-1)!= slash)
    1881           &&(back == NULL || (back!=NULL && s-1 != back) ))//MBCS DBCS
    1882       {
    1883         *s = backslash;
    1884         s++;
    1885       }
     1859          if (s > string_buffer && s[-1] != slash && s[-1] != backslash)
     1860        *s++ = backslash;
    18861861      while (*fname && (*fname!= slash) && (*fname!=backslash))
    18871862      {
    1888         *s = *fname++;
    1889         if ((size_t)((++s)-string_buffer) > maxlen)
     1863        if (s > string_buffer + maxlen)
    18901864          G_THROW( ERR_MSG("GURL.big_name") );
     1865        *s++ = *fname++;
    18911866      }
    18921867      *s = 0;
    1893       for(;(*fname== slash)||(*fname==backslash);fname++)
    1894         EMPTY_LOOP;
    1895     }
    1896   }
    1897 #elif defined(macintosh) // MACINTOSH implementation
    1898   strcpy(string_buffer, (const char *)(from?from:GOS::cwd()));
    1899  
    1900   if (!GStringRep::cmp(fname, string_buffer,strlen(string_buffer)) || is_file(fname))
    1901   {
    1902     strcpy(string_buffer, "");//please don't expand, the logic of filename is chaos.
    1903   }
    1904  
    1905   // Process path components
    1906   char *s = string_buffer + strlen(string_buffer);
    1907   if(fname)
    1908   {
    1909     for(;fname[0]==colon;fname++)
    1910       EMPTY_LOOP;
    1911     while(fname[0])
    1912     {
    1913       if (fname[0]== dot )
    1914       {
    1915         if (fname[1]==colon || !fname[1])
    1916         {
    1917           fname++;
    1918           continue;
    1919         }
    1920         if ((fname[1]== dot )
    1921           &&(fname[2]==colon || fname[2]==0))
    1922         {
    1923           fname +=2;
    1924           for(;(s>string_buffer+1)&&(*(s-1)==colon);s--)
    1925             EMPTY_LOOP;
    1926           for(;(s>string_buffer+1)&&(*(s-1)!=colon);s--)
    1927             EMPTY_LOOP;
    1928           continue;
    1929         }
    1930       }
    1931       if ((s==string_buffer)||(*(s-1)!=colon))
    1932       {
    1933         *s = colon;
    1934         s++;
    1935       }
    1936       while (*fname!=0 && *fname!=colon)
    1937       {
    1938         *s = *fname++;
    1939         if ((++s)-string_buffer > maxlen)
    1940           G_THROW( ERR_MSG("GURL.big_name") );
    1941       }
    1942       *s = 0;
    1943       for(;fname[0]==colon;fname++)
    1944         EMPTY_LOOP;
    1945     }
    1946   }
    1947   for(;(s>string_buffer+1) && (*(s-1)==colon);s--)
    1948     EMPTY_LOOP;
    1949   *s = 0;
    1950   return ((string_buffer[0]==colon)?(string_buffer+1):string_buffer);
     1868    }
     1869  }
    19511870#else
    19521871# error "Define something here for your operating system"
  • trunk/libdjvu/GURL.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GURL.h,v 1.11 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GURL.h,v 1.13 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _GURL_H_
     
    9292// and file status code (only for local file: urls).
    9393
    94     @version #$Id: GURL.h,v 1.11 2007/03/25 20:48:32 leonb Exp $#
     94    @version #$Id: GURL.h,v 1.13 2008/01/27 11:36:27 leonb Exp $#
    9595*/
    9696
     
    117117*/
    118118
    119 class GURL
     119class DJVUAPI GURL
    120120{
    121121public:
     
    371371};
    372372
    373 class GURL::UTF8 : public GURL
     373class DJVUAPI GURL::UTF8 : public GURL
    374374{
    375375public:
     
    378378};
    379379
    380 class GURL::Native : public GURL
     380class DJVUAPI GURL::Native : public GURL
    381381{
    382382public:
     
    385385};
    386386
    387 class GURL::Filename : public GURL
     387class DJVUAPI GURL::Filename : public GURL
    388388{
    389389public:
     
    394394};
    395395
    396 class GURL::Filename::UTF8 : public GURL::Filename
     396class DJVUAPI GURL::Filename::UTF8 : public GURL::Filename
    397397{
    398398public:
     
    400400};
    401401
    402 class GURL::Filename::Native : public GURL::Filename
     402class DJVUAPI GURL::Filename::Native : public GURL::Filename
    403403{
    404404public:
  • trunk/libdjvu/GUnicode.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: GUnicode.cpp,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: GUnicode.cpp,v 1.14 2009/05/17 23:57:42 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    6565
    6666#include "GString.h"
     67
    6768#if HAS_ICONV
    6869#include <iconv.h>
     70#endif
     71
     72#if !defined(AUTOCONF) || HAVE_STDINT_H
     73# include <stdint.h>
     74#elif HAVE_INTTYPES_H
     75# include <inttypes.h>
    6976#endif
    7077
     
    189196  virtual GP<Unicode> get_remainder(void) const;
    190197};
    191 // static unsigned long UTF8toUCS4(unsigned char const *&,void const * const);
    192 static unsigned long xUTF16toUCS4(unsigned short const *&s,void const * const);
    193 static unsigned long UTF16BEtoUCS4(unsigned char const *&s,void const * const);
    194 static unsigned long UTF16LEtoUCS4(unsigned char const *&s,void const * const);
    195 static unsigned long UCS4BEtoUCS4(unsigned char const *&s,void const * const);
    196 static unsigned long UCS4LEtoUCS4(unsigned char const *&s,void const * const);
    197 static unsigned long UCS4_3412toUCS4(unsigned char const *&s,void const * const);
    198 static unsigned long UCS4_2143toUCS4(unsigned char const *&s,void const * const);
     198// static uint32_t UTF8toUCS4(unsigned char const *&,void const * const);
     199static uint32_t xUTF16toUCS4(uint16_t const *&s,void const * const);
     200static uint32_t UTF16BEtoUCS4(unsigned char const *&s,void const * const);
     201static uint32_t UTF16LEtoUCS4(unsigned char const *&s,void const * const);
     202static uint32_t UCS4BEtoUCS4(unsigned char const *&s,void const * const);
     203static uint32_t UCS4LEtoUCS4(unsigned char const *&s,void const * const);
     204static uint32_t UCS4_3412toUCS4(unsigned char const *&s,void const * const);
     205static uint32_t UCS4_2143toUCS4(unsigned char const *&s,void const * const);
    199206
    200207GP<GStringRep>
     
    353360            GPBuffer<char> gutf8buf(utf8buf,pleft);
    354361            char *p=utf8buf;
    355             unsigned char const *last=ptr;
    356             for(;iconv_adaptor(iconv, cv, (char**)&ptr, &ptrleft, &p, &pleft);last=ptr)
    357               EMPTY_LOOP;
     362            char *nptr = (char*)ptr;
     363            while(iconv_adaptor(iconv, cv, &nptr, &ptrleft, &p, &pleft))
     364              ptr = (unsigned char*)nptr;
    358365            iconv_close(cv);
    359             retval=create(utf8buf,(size_t)last-(size_t)buf,t);
    360             retval->set_remainder(last,(size_t)eptr-(size_t)last,e);
     366            retval=create(utf8buf,(size_t)ptr-(size_t)buf,t);
     367            retval->set_remainder(ptr,(size_t)eptr-(size_t)ptr,e);
    361368          }
    362369        }
     
    396403      case XUCS4_3412:
    397404      {
    398         for(unsigned long w;
    399           (eptr<xeptr)&&(w=*(unsigned long const *)eptr);
    400           eptr+=sizeof(unsigned long))
     405        for(uint32_t w;
     406          (eptr<xeptr)&&(w=*(uint32_t const *)eptr);
     407          eptr+=sizeof(uint32_t))
    401408        {
    402409          maxutf8size+=(w>0x7f)?6:1;
     
    408415      case XUTF16LE:
    409416      {
    410         for(unsigned short w;
    411           (eptr<xeptr)&&(w=*(unsigned short const *)eptr);
    412           eptr+=sizeof(unsigned short))
     417        for(uint16_t w;
     418          (eptr<xeptr)&&(w=*(uint16_t const *)eptr);
     419          eptr+=sizeof(uint16_t))
    413420        {
    414421          maxutf8size+=3;
     
    437444      int len=0;
    438445      unsigned char const *iptr=(unsigned char *)buf;
    439       unsigned long w;
     446      uint16_t const *sptr=(uint16_t *)buf;
     447      uint32_t w;
    440448      switch(t)
    441449      {
    442450        case XUCS4:
    443451          for(;
    444             (iptr<eptr)&&(w=*(unsigned long const *)iptr);
    445             len++,iptr+=sizeof(unsigned long const))
     452            (iptr<eptr)&&(w=*(uint32_t const *)iptr);
     453            len++,iptr+=sizeof(uint32_t const))
    446454          {
    447455            optr=UCS4toUTF8(w,optr);
     
    473481          break;
    474482        case XUTF16:
    475           for(;
    476             (w=xUTF16toUCS4((unsigned short const*&)iptr,eptr));
    477             len++)
     483          for(;(w=xUTF16toUCS4(sptr,eptr));len++)
    478484          {
    479485            optr=UCS4toUTF8(w,optr);
     
    533539}
    534540
    535 static unsigned long
    536 xUTF16toUCS4(unsigned short const *&s,void const * const eptr)
    537 {
    538   unsigned long U=0;
    539   unsigned short const * const r=s+1;
     541static uint32_t
     542xUTF16toUCS4(uint16_t const *&s,void const * const eptr)
     543{
     544  uint32_t U=0;
     545  uint16_t const * const r=s+1;
    540546  if(r <= eptr)
    541547  {
    542     unsigned long const W1=s[0];
     548    uint32_t const W1=s[0];
    543549    if((W1<0xD800)||(W1>0xDFFF))
    544550    {
     
    549555    }else if(W1<=0xDBFF)
    550556    {
    551       unsigned short const * const rr=r+1;
     557      uint16_t const * const rr=r+1;
    552558      if(rr <= eptr)
    553559      {
    554         unsigned long const W2=s[1];
     560        uint32_t const W2=s[1];
    555561        if(((W2>=0xDC00)||(W2<=0xDFFF))&&((U=(0x1000+((W1&0x3ff)<<10))|(W2&0x3ff))))
    556562        {
     
    567573}
    568574
    569 static unsigned long
     575static uint32_t
    570576UTF16BEtoUCS4(unsigned char const *&s,void const * const eptr)
    571577{
    572   unsigned long U=0;
     578  uint32_t U=0;
    573579  unsigned char const * const r=s+2;
    574580  if(r <= eptr)
    575581  {
    576     unsigned long const C1MSB=s[0];
     582    uint32_t const C1MSB=s[0];
    577583    if((C1MSB<0xD8)||(C1MSB>0xDF))
    578584    {
    579       if((U=((C1MSB<<8)|((unsigned long)s[1]))))
     585      if((U=((C1MSB<<8)|((uint32_t)s[1]))))
    580586      {
    581587        s=r;
     
    586592      if(rr <= eptr)
    587593      {
    588         unsigned long const C2MSB=s[2];
     594        uint32_t const C2MSB=s[2];
    589595        if((C2MSB>=0xDC)||(C2MSB<=0xDF))
    590596        {
    591           U=0x10000+((unsigned long)s[1]<<10)+(unsigned long)s[3]
     597          U=0x10000+((uint32_t)s[1]<<10)+(uint32_t)s[3]
    592598            +(((C1MSB<<18)|(C2MSB<<8))&0xc0300);
    593599          s=rr;
    594600        }else
    595601        {
    596           U=(unsigned int)(-1)-((C1MSB<<8)|((unsigned long)s[1]));
     602          U=(unsigned int)(-1)-((C1MSB<<8)|((uint32_t)s[1]));
    597603          s=r;
    598604        }
     
    603609}
    604610
    605 static unsigned long
     611static uint32_t
    606612UTF16LEtoUCS4(unsigned char const *&s,void const * const eptr)
    607613{
    608   unsigned long U=0;
     614  uint32_t U=0;
    609615  unsigned char const * const r=s+2;
    610616  if(r <= eptr)
    611617  {
    612     unsigned long const C1MSB=s[1];
     618    uint32_t const C1MSB=s[1];
    613619    if((C1MSB<0xD8)||(C1MSB>0xDF))
    614620    {
    615       if((U=((C1MSB<<8)|((unsigned long)s[0]))))
     621      if((U=((C1MSB<<8)|((uint32_t)s[0]))))
    616622      {
    617623        s=r;
     
    622628      if(rr <= eptr)
    623629      {
    624         unsigned long const C2MSB=s[3];
     630        uint32_t const C2MSB=s[3];
    625631        if((C2MSB>=0xDC)||(C2MSB<=0xDF))
    626632        {
    627           U=0x10000+((unsigned long)s[0]<<10)+(unsigned long)s[2]
     633          U=0x10000+((uint32_t)s[0]<<10)+(uint32_t)s[2]
    628634            +(((C1MSB<<18)|(C2MSB<<8))&0xc0300);
    629635          s=rr;
    630636        }else
    631637        {
    632           U=(unsigned int)(-1)-((C1MSB<<8)|((unsigned long)s[1]));
     638          U=(unsigned int)(-1)-((C1MSB<<8)|((uint32_t)s[1]));
    633639          s=r;
    634640        }
     
    639645}
    640646
    641 static unsigned long
     647static uint32_t
    642648UCS4BEtoUCS4(unsigned char const *&s,void const * const eptr)
    643649{
    644   unsigned long U=0;
     650  uint32_t U=0;
    645651  unsigned char const * const r=s+4;
    646652  if(r<=eptr)
    647653  {
    648     U=(((((((unsigned long)s[0]<<8)|(unsigned long)s[1])<<8)|(unsigned long)s[2])<<8)|(unsigned long)s[3]);
     654    U=(((((((uint32_t)s[0]<<8)|(uint32_t)s[1])<<8)|(uint32_t)s[2])<<8)|(uint32_t)s[3]);
    649655    if(U)
    650656    {
     
    655661}
    656662
    657 static unsigned long
     663static uint32_t
    658664UCS4LEtoUCS4(unsigned char const *&s,void const * const eptr)
    659665{
    660   unsigned long U=0;
     666  uint32_t U=0;
    661667  unsigned char const * const r=s+4;
    662668  if(r<=eptr)
    663669  {
    664     U=(((((((unsigned long)s[3]<<8)|(unsigned long)s[2])<<8)|(unsigned long)s[1])<<8)|(unsigned long)s[0]);
     670    U=(((((((uint32_t)s[3]<<8)|(uint32_t)s[2])<<8)|(uint32_t)s[1])<<8)|(uint32_t)s[0]);
    665671    if(U)
    666672    {
     
    671677}
    672678
    673 static unsigned long
     679static uint32_t
    674680UCS4_2143toUCS4(unsigned char const *&s,void const * const eptr)
    675681{
    676   unsigned long U=0;
     682  uint32_t U=0;
    677683  unsigned char const * const r=s+4;
    678684  if(r<=eptr)
    679685  {
    680     U=(((((((unsigned long)s[1]<<8)|(unsigned long)s[0])<<8)|(unsigned long)s[3])<<8)|(unsigned long)s[2]);
     686    U=(((((((uint32_t)s[1]<<8)|(uint32_t)s[0])<<8)|(uint32_t)s[3])<<8)|(uint32_t)s[2]);
    681687    if(U)
    682688    {
     
    687693}
    688694
    689 static unsigned long
     695static uint32_t
    690696UCS4_3412toUCS4(unsigned char const *&s,void const * const eptr)
    691697{
    692   unsigned long U=0;
     698  uint32_t U=0;
    693699  unsigned char const * const r=s+4;
    694700  if(r<=eptr)
    695701  {
    696     U=(((((((unsigned long)s[2]<<8)|(unsigned long)s[3])<<8)|(unsigned long)s[0])<<8)|(unsigned long)s[1]);
     702    U=(((((((uint32_t)s[2]<<8)|(uint32_t)s[3])<<8)|(uint32_t)s[0])<<8)|(uint32_t)s[1]);
    697703    if(U)
    698704    {
  • trunk/libdjvu/IFFByteStream.cpp

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: IFFByteStream.cpp,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: IFFByteStream.cpp,v 1.13 2008/03/16 14:07:06 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
     
    150150      return -1;
    151151  // check composite chunks
    152   static char *szComposite[] = { "FORM", "LIST", "PROP", "CAT ", 0 };
     152  static const char *szComposite[] = { "FORM", "LIST", "PROP", "CAT ", 0 };
    153153  for (i=0; szComposite[i]; i++)
    154154    if (!memcmp(id, szComposite[i], 4))
    155155      return 1;
    156156  // check reserved chunks
    157   static char *szReserved[] = { "FOR", "LIS", "CAT", 0 };
     157  static const char *szReserved[] = { "FOR", "LIS", "CAT", 0 };
    158158  for (i=0; szReserved[i]; i++)
    159159    if (!memcmp(id, szReserved[i], 3) && id[3]>='1' && id[3]<='9')
  • trunk/libdjvu/IFFByteStream.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: IFFByteStream.h,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: IFFByteStream.h,v 1.13 2007/05/19 03:07:34 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _IFFBYTESTREAM_H_
     
    124124
    125125    @version
    126     #$Id: IFFByteStream.h,v 1.12 2007/03/25 20:48:32 leonb Exp $# */
     126    #$Id: IFFByteStream.h,v 1.13 2007/05/19 03:07:34 leonb Exp $# */
    127127//@{
    128128
     
    181181    ByteStream.  */
    182182
    183 class IFFByteStream : protected ByteStream::Wrapper
     183class DJVUAPI IFFByteStream : protected ByteStream::Wrapper
    184184{
    185185protected:
  • trunk/libdjvu/IW44EncodeCodec.cpp

    r206 r280  
    5555//
    5656// $Id: IW44EncodeCodec.cpp,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/IW44Image.cpp

    r206 r280  
    5555//
    5656// $Id: IW44Image.cpp,v 1.13 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/IW44Image.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: IW44Image.h,v 1.12 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: IW44Image.h,v 1.13 2007/05/19 03:07:34 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef IW44IMAGE_H_
     
    163163
    164164    @version
    165     #$Id: IW44Image.h,v 1.12 2007/03/25 20:48:32 leonb Exp $# */
     165    #$Id: IW44Image.h,v 1.13 2007/05/19 03:07:34 leonb Exp $# */
    166166//@{
    167167
     
    191191    meeting either the slice target, the size target or the decibel target.  */
    192192
    193 struct IWEncoderParms
     193struct DJVUAPI IWEncoderParms
    194194{
    195195  /** Slice target.  Data generation for the current chunk stops if the total
     
    226226    class. */
    227227
    228 class IW44Image : public GPEnabled
     228class DJVUAPI IW44Image : public GPEnabled
    229229{
    230230public:
     
    396396    of this class. */
    397397
    398 class IWBitmap : public IW44Image
     398class DJVUAPI IWBitmap : public IW44Image
    399399{
    400400public:
     
    474474    class. */
    475475
    476 class IWPixmap : public IW44Image
     476class DJVUAPI IWPixmap : public IW44Image
    477477{
    478478public:
  • trunk/libdjvu/JB2EncodeCodec.cpp

    r206 r280  
    5555//
    5656// $Id: JB2EncodeCodec.cpp,v 1.10 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/JB2Image.cpp

    r206 r280  
    5555//
    5656// $Id: JB2Image.cpp,v 1.13 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $
    5858
    5959#ifdef HAVE_CONFIG_H
  • trunk/libdjvu/JB2Image.h

    r206 r280  
    5454//C- +------------------------------------------------------------------
    5555//
    56 // $Id: JB2Image.h,v 1.11 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     56// $Id: JB2Image.h,v 1.13 2008/01/27 11:36:27 leonb Exp $
     57// $Name: release_3_5_22 $
    5858
    5959#ifndef _JB2IMAGE_H
     
    159159
    160160    @version
    161     #$Id: JB2Image.h,v 1.11 2007/03/25 20:48:32 leonb Exp $#
     161    #$Id: JB2Image.h,v 1.13 2008/01/27 11:36:27 leonb Exp $#
    162162    @memo
    163163    Coding bilevel images with JB2.
     
    198198    #shapeno# is the subscript of the shape to be rendered.  */
    199199
    200 class JB2Blit {
     200class DJVUAPI JB2Blit {
    201201public:
    202202  /** Horizontal coordinate of the blit. */
     
    215215    the parent shape.  */
    216216
    217 class JB2Shape
     217class DJVUAPI JB2Shape
    218218{
    219219public:
     
    250250/** Dictionary of JB2 shapes. */
    251251
    252 class JB2Dict : public GPEnabled
     252class DJVUAPI JB2Dict : public GPEnabled
    253253{
    254254protected:
     
    345345    JB2 data. */
    346346
    347 class JB2Image : public JB2Dict
     347class DJVUAPI JB2Image : public JB2Dict
    348348{
    349349protected:
  • trunk/libdjvu/JPEGDecoder.cpp

    r206 r280  
    5555//
    5656// $Id: JPEGDecoder.cpp,v 1.9 2007/03/25 20:48:32 leonb Exp $
    57 // $Name: release_3_5_19 $
     57// $Name: release_3_5_22 $