//C-  -*- C++ -*-

//C- -------------------------------------------------------------------

//C- DjVuLibre-3.5

//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.

//C- Copyright (c) 2001  AT&T

//C-

//C- This software is subject to, and may be distributed under, the

//C- GNU General Public License, either Version 2 of the license,

//C- or (at your option) any later version. The license should have

//C- accompanied the software or you may obtain a copy of the license

//C- from the Free Software Foundation at http://www.fsf.org .

//C-

//C- This program is distributed in the hope that it will be useful,

//C- but WITHOUT ANY WARRANTY; without even the implied warranty of

//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//C- GNU General Public License for more details.

//C- 

//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):

//C-

//C-  ------------------------------------------------------------------

//C- | DjVu (r) Reference Library (v. 3.5)

//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.

//C- | The DjVu Reference Library is protected by U.S. Pat. No.

//C- | 6,058,214 and patents pending.

//C- |

//C- | This software is subject to, and may be distributed under, the

//C- | GNU General Public License, either Version 2 of the license,

//C- | or (at your option) any later version. The license should have

//C- | accompanied the software or you may obtain a copy of the license

//C- | from the Free Software Foundation at http://www.fsf.org .

//C- |

//C- | The computer code originally released by LizardTech under this

//C- | license and unmodified by other parties is deemed "the LIZARDTECH

//C- | ORIGINAL CODE."  Subject to any third party intellectual property

//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 

//C- | non-exclusive license to make, use, sell, or otherwise dispose of 

//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 

//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 

//C- | General Public License.   This grant only confers the right to 

//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 

//C- | the extent such infringement is reasonably necessary to enable 

//C- | recipient to make, have made, practice, sell, or otherwise dispose 

//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 

//C- | any greater extent that may be necessary to utilize further 

//C- | modifications or combinations.

//C- |

//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY

//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF

//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

//C- +------------------------------------------------------------------

// From: Leon Bottou, 1/31/2002

// This file has very little to do with my initial implementation.

// It has been practically rewritten by Lizardtech for i18n changes.

// My original implementation was very small in comparison

// <http://prdownloads.sourceforge.net/djvu/DjVu2_2b-src.tgz>.

// In my opinion, the duplication of the string classes is a failed

// attempt to use the type system to enforce coding policies.

// This could be fixed.  But there are better things to do in djvulibre.

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "GString.h"

#include "GThreads.h"

#include "debug.h"

#include <stddef.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#if HAS_WCHAR

# include <locale.h>

# if !defined(AUTOCONF) || HAVE_WCHAR_H

#  include <wchar.h>

# endif

# if HAS_WCTYPE

#  include <wctype.h>

# endif

#endif

#include <ctype.h>

#ifndef LC_NUMERIC          //MingW

# undef DO_CHANGELOCALE

# define LC_NUMERIC 0

#endif

#ifndef DO_CHANGELOCALE

# define DO_CHANGELOCALE 0

#endif

#ifdef HAVE_NAMESPACES

namespace DJVU {

# ifdef NOT_DEFINED // Just to fool emacs c++ mode

}

#endif

#endif

GBaseString::~GBaseString() {}

GNativeString::~GNativeString() {}

GUTF8String::~GUTF8String() {}

#if !HAS_MBSTATE && HAS_WCHAR

// Under some systems, wctomb() and mbtowc() are not thread

// safe.  In those cases, wcrtomb and mbrtowc are preferred.

// For Solaris, wctomb() and mbtowc() are thread safe, and 

// wcrtomb() and mbrtowc() don't exist.

#define wcrtomb MYwcrtomb

#define mbrtowc MYmbrtowc

#define mbrlen  MYmbrlen

static inline int

wcrtomb(char *bytes,wchar_t w,mbstate_t *)

{

  return wctomb(bytes,w);

}

static inline int

mbrtowc(wchar_t *w,const char *source, size_t n, mbstate_t *)

{

  return mbtowc(w,source,n);

}

static inline size_t

mbrlen(const char *s, size_t n, mbstate_t *)

{

  return mblen(s,n);

}

#endif // !HAS_MBSTATE || HAS_WCHAR

GP<GStringRep>

GStringRep::upcase(void) const

{ return tocase(giswupper,gtowupper); }

GP<GStringRep>

GStringRep::downcase(void) const

{ return tocase(giswlower,gtowlower); }

GP<GStringRep>

GStringRep::UTF8::create(const unsigned int sz)

{

  return GStringRep::create(sz,(GStringRep::UTF8 *)0);

}

GP<GStringRep>

GStringRep::UTF8::create(const char *s)

{

  GStringRep::UTF8 dummy;

  return dummy.strdup(s);

}

GP<GStringRep> 

GStringRep::UTF8::create(const GP<GStringRep> &s1,const GP<GStringRep> &s2)

{

  GStringRep::UTF8 dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep> 

GStringRep::UTF8::create( const GP<GStringRep> &s1,const char *s2)

{

  GStringRep::UTF8 dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep> 

GStringRep::UTF8::create( const char *s1, const GP<GStringRep> &s2)

{

  GStringRep::UTF8 dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep> 

GStringRep::UTF8::create( const char *s1,const char *s2)

{ 

  GStringRep::UTF8 dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep> 

GStringRep::UTF8::create(const char *s,const int start,const int length)

{

  GStringRep::UTF8 dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep> 

GStringRep::UTF8::create(

  const uint16_t *s,const int start,const int length)

{

  GStringRep::UTF8 dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep>

GStringRep::UTF8::create(

  const uint32_t *s,const int start,const int length)

{

  GStringRep::UTF8 dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep> 

GStringRep::UTF8::blank(const unsigned int sz) const

{

   return GStringRep::create(sz,(GStringRep::UTF8 *)0);

}

bool

GStringRep::UTF8::isUTF8(void) const

{

  return true;

}

GP<GStringRep> 

GStringRep::UTF8::toThis(

    const GP<GStringRep> &rep,const GP<GStringRep> &) const

{

  return rep?(rep->toUTF8(true)):rep;

}

GP<GStringRep> 

GStringRep::UTF8::create(const char fmt[],va_list& args)

{ 

  const GP<GStringRep> s(create(fmt));

  return (s?(s->vformat(args)):s);

}

#if !HAS_WCHAR

#define NATIVE_CREATE(x) UTF8::create( x );

#ifdef LC_ALL

#undef LC_ALL

#endif

#define LC_ALL 0

class GStringRep::ChangeLocale

{

public:

  ChangeLocale(const int,const char *) {}

  ~ChangeLocale() {};

};

GP<GStringRep>

GStringRep::NativeToUTF8( const char *s )

{

  return GStringRep::UTF8::create(s);

}

#else

#define NATIVE_CREATE(x) Native::create( x );

// The declaration and implementation of GStringRep::ChangeLocale

// Not used in WinCE

class GStringRep::ChangeLocale

{

public:

  ChangeLocale(const int category,const char locale[]);

  ~ChangeLocale();

private:

  GUTF8String locale;

  int category;

};

class GStringRep::Native : public GStringRep

{

public:

  // default constructor

  Native(void);

  // virtual destructor

  virtual ~Native();

    // Other virtual methods.

      // Create an empty string.

  virtual GP<GStringRep> blank(const unsigned int sz = 0) const;

      // Append a string.

  virtual GP<GStringRep> append(const GP<GStringRep> &s2) const;

      // Test if Native.

  virtual bool isNative(void) const;

      // Convert to Native.

  virtual GP<GStringRep> toNative(

    const EscapeMode escape=UNKNOWN_ESCAPED) const;

      // Convert to UTF8.

  virtual GP<GStringRep> toUTF8(const bool nothrow=false) const;

      // Convert to UTF8.

  virtual GP<GStringRep> toThis(

     const GP<GStringRep> &rep,const GP<GStringRep> &) const;

      // Compare with #s2#.

  virtual int cmp(const GP<GStringRep> &s2, const int len=(-1)) const;

  // Convert strings to numbers.

  virtual int toInt(void) const;

  virtual long toLong(

    const int pos, int &endpos, const int base=10) const;

  virtual unsigned long toULong(

    const int pos, int &endpos, const int base=10) const;

  virtual double toDouble(

    const int pos, int &endpos) const;

    // Create an empty string

  static GP<GStringRep> create(const unsigned int sz = 0);

    // Create a strdup string.

  static GP<GStringRep> create(const char *s);

  // Creates by appending to the current string

   // Creates with a concat operation.

  static GP<GStringRep> create(

    const GP<GStringRep> &s1,const GP<GStringRep> &s2;;

  static GP<GStringRep> create( const GP<GStringRep> &s1,const char *s2);

  static GP<GStringRep> create( const char *s1, const GP<GStringRep> &s2;;

  static GP<GStringRep> create(const char *s1,const char *s2);

    // Create with a strdup and substr operation.

  static GP<GStringRep> create(

    const char *s,const int start,const int length=(-1));

  static GP<GStringRep> create(

    const uint16_t *s,const int start,const int length=(-1));

  static GP<GStringRep> create(

    const uint32_t *s,const int start,const int length=(-1));

    // Create with an sprintf()

  static GP<GStringRep> create_format(const char fmt[],...);

  static GP<GStringRep> create(const char fmt[],va_list &args);

  virtual unsigned char *UCS4toString(

    const uint32_t w,unsigned char *ptr, mbstate_t *ps=0) const;

  // Tests if a string is legally encoded in the current character set.

  virtual bool is_valid(void) const;

  virtual int ncopy(wchar_t * const buf, const int buflen) const;

  friend class GBaseString;

protected:

  // Return the next character and increment the source pointer.

  virtual uint32_t getValidUCS4(const char *&source) const;

};

GP<GStringRep>

GStringRep::Native::create(const unsigned int sz)

{

  return GStringRep::create(sz,(GStringRep::Native *)0);

}

    // Create a strdup string.

GP<GStringRep>

GStringRep::Native::create(const char *s)

{

  GStringRep::Native dummy;

  return dummy.strdup(s);

}

GP<GStringRep>

GStringRep::Native::create(const GP<GStringRep> &s1,const GP<GStringRep> &s2)

{

  GStringRep::Native dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep> 

GStringRep::Native::create( const GP<GStringRep> &s1,const char *s2)

{

  GStringRep::Native dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep>

GStringRep::Native::create( const char *s1, const GP<GStringRep> &s2)

{

  GStringRep::Native dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep>

GStringRep::Native::create(const char *s1,const char *s2)

{

  GStringRep::Native dummy;

  return dummy.concat(s1,s2);

}

GP<GStringRep>

GStringRep::Native::create(

  const char *s,const int start,const int length)

{

  GStringRep::Native dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep>

GStringRep::Native::create(

    const uint16_t *s,const int start,const int length)

{

  GStringRep::Native dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep>

GStringRep::Native::create(

  const uint32_t *s,const int start,const int length)

{

  GStringRep::Native dummy;

  return dummy.substr(s,start,length);

}

GP<GStringRep> 

GStringRep::Native::blank(const unsigned int sz) const

{

  return GStringRep::create(sz,(GStringRep::Native *)0);

}

bool

GStringRep::Native::isNative(void) const

{

  return true;

}

GP<GStringRep>

GStringRep::Native::toThis(

     const GP<GStringRep> &rep,const GP<GStringRep> &) const

{

  return rep?(rep->toNative(NOT_ESCAPED)):rep;

}

GP<GStringRep> 

GStringRep::Native::create(const char fmt[],va_list &args)

{ 

  const GP<GStringRep> s(create(fmt));

  return (s?(s->vformat(args)):s);

}

int

GStringRep::Native::ncopy(

  wchar_t * const buf, const int buflen ) const

{

  return toUTF8()->ncopy(buf,buflen);

}

GStringRep::ChangeLocale::ChangeLocale(const int xcategory, const char xlocale[] )

  : category(xcategory)

{

#if DO_CHANGELOCALE

  // This is disabled under UNIX because 

  // it does not play nice with MT.

  if(xlocale)

    {

      locale=setlocale(xcategory,0);

      if(locale.length() &&(locale!=xlocale))

        {

          if(locale == setlocale(category,xlocale))

            {

              locale.empty();

            }

        }

      else

        {

          locale.empty();

        }

    }

#endif

}

GStringRep::ChangeLocale::~ChangeLocale()

{

#if DO_CHANGELOCALE

  if(locale.length())

    {

      setlocale(category,(const char *)locale);

    }

#endif

}

GNativeString &

GNativeString::format(const char fmt[], ... )

{

  va_list args;

  va_start(args, fmt);

  return init(GStringRep::Native::create(fmt,args));

}

// Gather the native implementations here. Not used in WinCE.

GStringRep::Native::Native(void) {}

GStringRep::Native::~Native() {}

GP<GStringRep>

GStringRep::Native::append(const GP<GStringRep> &s2) const

{

  GP<GStringRep> retval;

  if(s2)

  {

    if(s2->isUTF8())

    {

      G_THROW( ERR_MSG("GStringRep.appendUTF8toNative") );

    }

    retval=concat(data,s2->data);

  }else

  {

    retval=const_cast<GStringRep::Native *>(this); 

  }

  return retval;

}

GP<GStringRep>

GStringRep::Native::create_format(const char fmt[],...)

{

  va_list args;

  va_start(args, fmt);

  return create(fmt,args);

}

unsigned char *

GStringRep::Native::UCS4toString(

  const uint32_t w0,unsigned char *ptr, mbstate_t *ps) const

{

  return UCS4toNative(w0,ptr,ps);

}

// Convert a UCS4 to a multibyte string in the value bytes.  

// The data pointed to by ptr should be long enough to contain

// the results with a nill termination.  (Normally 7 characters

// is enough.)

unsigned char *

GStringRep::UCS4toNative(const uint32_t w0,unsigned char *ptr, mbstate_t *ps)

{

  uint16_t w1;

  uint16_t w2=1;

  for(int count=(sizeof(wchar_t)==sizeof(w1)) 

        ? UCS4toUTF16(w0,w1,w2) : 1;

      count;

      --count,w1=w2)

    {

      // wchar_t can be either UCS4 or UCS2

      const wchar_t w=(sizeof(wchar_t) == sizeof(w1))?(wchar_t)w1:(wchar_t)w0;

      int i=wcrtomb((char *)ptr,w,ps);

      if(i<0)

        break;

      ptr[i]=0;

      ptr += i;

    }

  ptr[0]=0;

  return ptr;

}

GP<GStringRep>

GStringRep::Native::toNative(const EscapeMode escape) const

{

  if(escape == UNKNOWN_ESCAPED)

    G_THROW( ERR_MSG("GStringRep.NativeToNative") );

  return const_cast<GStringRep::Native *>(this);

}

GP<GStringRep>

GStringRep::Native::toUTF8(const bool) const

{

  unsigned char *buf;

  GPBuffer<unsigned char> gbuf(buf,size*6+1);

  buf[0]=0;

  if(data && size)

  {

    size_t n=size;

    const char *source=data;

    mbstate_t ps;

    unsigned char *ptr=buf;

    //(void)mbrlen(source, n, &ps);

    memset(&ps,0,sizeof(mbstate_t));

    int i=0;

    if(sizeof(wchar_t) == sizeof(uint32_t))

      {

        wchar_t w = 0;

        for(;(n>0)&&((i=mbrtowc(&w,source,n,&ps))>=0); n-=i,source+=i)

          {

            ptr=UCS4toUTF8((uint32_t)w,ptr);

          }

      }

    else

      { 

        wchar_t w = 0;

        for(;(n>0)&&((i=mbrtowc(&w,source,n,&ps))>=0);n-=i,source+=i)

          {

            uint16_t s[2];

            s[0]=w;

            uint32_t w0;

            if(UTF16toUCS4(w0,s,s+1)<=0)

              {

                source+=i;

                n-=i;

                if((n>0)&&((i=mbrtowc(&w,source,n,&ps))>=0))

                  {

                    s[1]=w;

                    if(UTF16toUCS4(w0,s,s+2)<=0)

                      {

                        i=(-1);

                        break;

                      }

                  }

                else

                  {

                    i=(-1);

                    break;

                  }

              }

            ptr=UCS4toUTF8(w0,ptr);

          }

      }

    if(i<0)

      {

        gbuf.resize(0);

      }

    else

      {

        ptr[0]=0;

      }

  }

  return GStringRep::UTF8::create((const char *)buf);

}

GNativeString

GBaseString::UTF8ToNative(

  const bool currentlocale,const EscapeMode escape) const

{

  const char *source=(*this);

  GP<GStringRep> retval;

  if(source && source[0]) 

    {

#if DO_CHANGELOCALE

      GUTF8String lc_ctype(setlocale(LC_CTYPE,0));

      bool repeat;

      for(repeat=!currentlocale;;repeat=false)

        {

#endif

          retval=(*this)->toNative((GStringRep::EscapeMode)escape);

#if DO_CHANGELOCALE

          if (!repeat || retval || (lc_ctype == setlocale(LC_CTYPE,"")))

            break;

        }

      if(!repeat)

        setlocale(LC_CTYPE,(const char *)lc_ctype);

#endif

    }

  return GNativeString(retval);

}

/*MBCS*/

GNativeString

GBaseString::getUTF82Native( EscapeMode escape ) const

{ //MBCS cvt

  GNativeString retval;

  // We don't want to convert this if it 

  // already is known to be native...

//  if (isNative()) return *this;

  const size_t slen=length()+1;

  if(slen>1)

  {

    retval=UTF8ToNative(false,escape) ;

    if(!retval.length())

    {

      retval=(const char*)*this;

    }

  }

  return retval;

}

GUTF8String

GBaseString::NativeToUTF8(void) const

{

  GP<GStringRep> retval;

  if(length())

  {

    const char *source=(*this);

#if DO_CHANGELOCALE

    GUTF8String lc_ctype=setlocale(LC_CTYPE,0);

    bool repeat;

    for(repeat=true;;repeat=false)

      {

#endif

        if( (retval=GStringRep::NativeToUTF8(source)) )

          if(GStringRep::cmp(retval->toNative(),source))

            retval=GStringRep::UTF8::create((unsigned int)0);

#if DO_CHANGELOCALE

        if(!repeat || retval || (lc_ctype == setlocale(LC_CTYPE,"")))

          break;

      }

    if(!repeat)

      setlocale(LC_CTYPE,(const char *)lc_ctype);

#endif

  }

  return GUTF8String(retval);

}

GUTF8String

GBaseString::getNative2UTF8(void) const

{ //MBCS cvt

   // We don't want to do a transform this

   // if we already are in the given type.

//   if (isUTF8()) return *this;

  const size_t slen=length()+1;

  GUTF8String retval;

  if(slen > 1)

  {

    retval=NativeToUTF8();

    if(!retval.length())

    {

      retval=(const char *)(*this);

    }

  }

  return retval;

} /*MBCS*/

int

GStringRep::Native::cmp(const GP<GStringRep> &s2,const int len) const

{

  int retval;

  if(s2)

  {

    if(s2->isUTF8())

    {

      const GP<GStringRep> r(toUTF8(true));

      if(r)

      {

        retval=GStringRep::cmp(r->data,s2->data,len);

      }else

      {

        retval=cmp(s2->toNative(NOT_ESCAPED),len);

      }

    }else

    {

      retval=GStringRep::cmp(data,s2->data,len);

    }

  }else

  {

    retval=GStringRep::cmp(data,0,len);

  }

  return retval;

}

int

GStringRep::Native::toInt() const

{

  return atoi(data);

}

long

GStringRep::Native::toLong(

  const int pos, int &endpos, const int base) const

{

   char *edata=0;

   const long retval=strtol(data+pos, &edata, base);

   if(edata)

   {

     endpos=(int)((size_t)edata-(size_t)data);

   }else

   {

     endpos=(-1);

   }

   return retval;

}

unsigned long

GStringRep::Native::toULong(

  const int pos, int &endpos, const int base) const

{

   char *edata=0;

   const unsigned long retval=strtoul(data+pos, &edata, base);

   if(edata)

   {

     endpos=(int)((size_t)edata-(size_t)data);

   }else

   {

     endpos=(-1);

   }

   return retval;

}

double

GStringRep::Native::toDouble(

  const int pos, int &endpos) const

{

   char *edata=0;

   const double retval=strtod(data+pos, &edata);

   if(edata)

   {

     endpos=(int)((size_t)edata-(size_t)data);

   }else

   {

     endpos=(-1);

   }

   return retval;

}

uint32_t

GStringRep::Native::getValidUCS4(const char *&source) const

{

  uint32_t retval=0;

  int n=(int)((size_t)size+(size_t)data-(size_t)source);

  if(source && (n > 0))

  {

    mbstate_t ps;

    //(void)mbrlen(source, n, &ps);

    memset(&ps,0,sizeof(mbstate_t));

    wchar_t wt;

    const int len=mbrtowc(&wt,source,n,&ps); 

    if(len>=0)

    {

      if(sizeof(wchar_t) == sizeof(uint16_t))

      {

        source+=len;

        uint16_t s[2];

        s[0]=(uint16_t)wt;

        if(UTF16toUCS4(retval,s,s+1)<=0)

        {

          if((n-=len)>0)

          {

            const int len=mbrtowc(&wt,source,n,&ps);

            if(len>=0)

            {

              s[1]=(uint16_t)wt;

              uint32_t w;

              if(UTF16toUCS4(w,s,s+2)>0)

              {

                source+=len;

                retval=w;

              }

            }

          }

        }

      }else

      {

        retval=(uint32_t)wt;

        source++;

      } 

    }else

    {

      source++;

    }

  }

  return retval;

}

// Tests if a string is legally encoded in the current character set.

bool 

GStringRep::Native::is_valid(void) const

{

  bool retval=true;

  if(data && size)

  {

    size_t n=size;

    const char *s=data;

    mbstate_t ps;

    //(void)mbrlen(s, n, &ps);

    memset(&ps,0,sizeof(mbstate_t));

    do

    {

      size_t m=mbrlen(s,n,&ps);

      if(m > n)

      {

        retval=false;

        break;

      }else if(m)

      {

        s+=m;