source: trunk/libdjvu/GUnicode.cpp @ 199

Last change on this file since 199 was 17, checked in by Eugene Romanenko, 16 years ago

update makefiles, remove absolute paths, update djvulibre to version 3.5.17

File size: 21.0 KB
Line 
1//C-  -*- C++ -*-
2//C- -------------------------------------------------------------------
3//C- DjVuLibre-3.5
4//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
5//C- Copyright (c) 2001  AT&T
6//C-
7//C- This software is subject to, and may be distributed under, the
8//C- GNU General Public License, Version 2. The license should have
9//C- accompanied the software or you may obtain a copy of the license
10//C- from the Free Software Foundation at http://www.fsf.org .
11//C-
12//C- This program is distributed in the hope that it will be useful,
13//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
14//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15//C- GNU General Public License for more details.
16//C-
17//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library
18//C- distributed by Lizardtech Software.  On July 19th 2002, Lizardtech
19//C- Software authorized us to replace the original DjVu(r) Reference
20//C- Library notice by the following text (see doc/lizard2002.djvu):
21//C-
22//C-  ------------------------------------------------------------------
23//C- | DjVu (r) Reference Library (v. 3.5)
24//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
25//C- | The DjVu Reference Library is protected by U.S. Pat. No.
26//C- | 6,058,214 and patents pending.
27//C- |
28//C- | This software is subject to, and may be distributed under, the
29//C- | GNU General Public License, Version 2. The license should have
30//C- | accompanied the software or you may obtain a copy of the license
31//C- | from the Free Software Foundation at http://www.fsf.org .
32//C- |
33//C- | The computer code originally released by LizardTech under this
34//C- | license and unmodified by other parties is deemed "the LIZARDTECH
35//C- | ORIGINAL CODE."  Subject to any third party intellectual property
36//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
37//C- | non-exclusive license to make, use, sell, or otherwise dispose of
38//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
39//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
40//C- | General Public License.   This grant only confers the right to
41//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
42//C- | the extent such infringement is reasonably necessary to enable
43//C- | recipient to make, have made, practice, sell, or otherwise dispose
44//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
45//C- | any greater extent that may be necessary to utilize further
46//C- | modifications or combinations.
47//C- |
48//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
49//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
50//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
51//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
52//C- +------------------------------------------------------------------
53//
54// $Id: GUnicode.cpp,v 1.11 2003/11/07 22:08:21 leonb Exp $
55// $Name:  $
56
57#ifdef HAVE_CONFIG_H
58# include "config.h"
59#endif
60#if NEED_GNUG_PRAGMAS
61# pragma implementation
62#endif
63
64#include "GString.h"
65#if HAS_ICONV
66#include <iconv.h>
67#endif
68
69
70#ifdef HAVE_NAMESPACES
71namespace DJVU {
72# ifdef NOT_DEFINED // Just to fool emacs c++ mode
73}
74#endif
75#endif
76
77static unsigned char nill=0;
78
79static void const * 
80checkmarks(void const * const xbuf,
81           unsigned int &bufsize,
82           GStringRep::EncodeType &rep)
83{
84  unsigned char const *buf=(unsigned char const *)xbuf;
85  if(bufsize >= 2 || (xbuf && !bufsize && rep != GStringRep::XOTHER))
86  {
87    const unsigned int s=(((unsigned int)buf[0])<<8)+(unsigned int)buf[1];
88    switch(s)
89    {
90      case 0:
91        if((bufsize>=4)||(!bufsize && rep == GStringRep::XUCS4BE)
92          ||(!bufsize && rep == GStringRep::XUCS4_2143))
93        {
94          const unsigned int s=(((unsigned int)buf[2])<<8)+(unsigned int)buf[3];
95          if(s == 0xfeff)
96          { 
97            rep=GStringRep::XUCS4BE;
98            buf+=4;
99          }else if(s == 0xfffe)
100          {
101            rep=GStringRep::XUCS4_2143;
102            buf+=4;
103          }
104        }
105        break;
106      case 0xfffe:
107        if(((bufsize>=4)||(!bufsize && rep == GStringRep::XUCS4LE)) 
108           && !((unsigned char *)buf)[2] && !((unsigned char *)buf)[3])
109        {
110          rep=GStringRep::XUCS4LE;
111          buf+=4;
112        }else
113        {
114          rep=GStringRep::XUTF16LE;
115          buf+=2;
116        }
117        break;
118      case 0xfeff:
119        if(((bufsize>=4)||(!bufsize && rep == GStringRep::XUCS4_3412)) 
120           && !((unsigned char *)buf)[2] && !((unsigned char *)buf)[3])
121        {
122          rep=GStringRep::XUCS4_3412;
123          buf+=4;
124        }else
125        {
126          rep=GStringRep::XUTF16LE;
127          buf+=2;
128        }
129        break;
130      case 0xefbb:
131        if(((bufsize>=3)||(!bufsize && GStringRep::XUTF8 == rep))&&(buf[2] == 0xbf))
132        {
133          rep=GStringRep::XUTF8;
134          buf+=3;
135        }
136        break;
137      default:
138        break;
139    }
140  }
141  if(buf != xbuf)
142  {
143    if(bufsize)
144    {
145      const size_t s=(size_t)xbuf-(size_t)buf;
146      if(bufsize> s)
147      {
148        bufsize-=s;
149      }else
150      {
151        bufsize=0;
152        buf=(const unsigned char *)&nill;
153      }
154    }
155  }
156  return buf;
157}
158
159class GStringRep::Unicode : public GStringRep::UTF8
160{
161public:
162  GP<GStringRep> encoding;
163  EncodeType encodetype;
164  void *remainder;
165  GPBufferBase gremainder;
166public:
167  Unicode(void);
168  /// virtual destructor.
169  virtual ~Unicode();
170
171  static GP<GStringRep> create(const unsigned int sz);
172  static GP<GStringRep> create(void const * const buf, unsigned int bufsize,
173                               const EncodeType, const GP<GStringRep> &encoding);
174  static GP<GStringRep> create( void const * const buf,
175    unsigned int size, const EncodeType encodetype );
176  static GP<GStringRep> create( void const * const buf,
177    const unsigned int size, GP<GStringRep> encoding );
178  static GP<GStringRep> create( void const * const buf,
179    const unsigned int size, const GP<Unicode> &remainder );
180
181protected:
182  virtual void set_remainder( void const * const buf, const unsigned int size,
183    const EncodeType encodetype );
184  virtual void set_remainder( void const * const buf, const unsigned int size,
185    const GP<GStringRep> &encoding );
186  virtual void set_remainder( const GP<Unicode> &remainder );
187  virtual GP<Unicode> get_remainder(void) const;
188};
189// static unsigned long UTF8toUCS4(unsigned char const *&,void const * const);
190static unsigned long xUTF16toUCS4(unsigned short const *&s,void const * const);
191static unsigned long UTF16BEtoUCS4(unsigned char const *&s,void const * const);
192static unsigned long UTF16LEtoUCS4(unsigned char const *&s,void const * const);
193static unsigned long UCS4BEtoUCS4(unsigned char const *&s,void const * const);
194static unsigned long UCS4LEtoUCS4(unsigned char const *&s,void const * const);
195static unsigned long UCS4_3412toUCS4(unsigned char const *&s,void const * const);
196static unsigned long UCS4_2143toUCS4(unsigned char const *&s,void const * const);
197
198GP<GStringRep>
199GStringRep::Unicode::create(const unsigned int sz)
200{
201  GP<GStringRep> gaddr;
202  if (sz > 0)
203  {
204    GStringRep *addr;
205    gaddr=(addr=new GStringRep::Unicode);
206    addr->data=(char *)(::operator new(sz+1));
207    addr->size = sz;
208    addr->data[sz] = 0;
209  }
210  return gaddr;
211}
212
213GStringRep::Unicode::Unicode(void)
214: encodetype(XUTF8), gremainder(remainder,0,1) {}
215
216GStringRep::Unicode::~Unicode() {}
217
218GP<GStringRep>
219GStringRep::Unicode::create(
220  void const * const xbuf,
221  unsigned int bufsize,
222  const EncodeType t,
223  const GP<GStringRep> &encoding)
224{
225  return (encoding->size)
226    ?create(xbuf,bufsize,encoding)
227    :create(xbuf,bufsize,t);
228}
229
230GP<GStringRep>
231GStringRep::Unicode::create(
232  void const * const xbuf,
233  const unsigned int bufsize,
234  const GP<Unicode> &xremainder )
235{
236  Unicode *r=xremainder;
237  GP<GStringRep> retval;
238  if(r)
239  {
240    const int s=r->gremainder;
241    if(xbuf && bufsize)
242    {
243      if(s)
244      {
245        void *buf;
246        GPBufferBase gbuf(buf,s+bufsize,1);
247        memcpy(buf,r->remainder,s);
248        memcpy((void *)((size_t)buf+s),xbuf,bufsize);
249        retval=((r->encoding)
250          ?create(buf,s+bufsize,r->encoding)
251          :create(buf,s+bufsize,r->encodetype));
252      }else
253      {
254        retval=((r->encoding)
255          ?create(xbuf,bufsize,r->encoding)
256          :create(xbuf,bufsize,r->encodetype));
257      }
258    }else if(s)
259        {
260      void *buf;
261      GPBufferBase gbuf(buf,s,1);
262      memcpy(buf,r->remainder,s);
263      retval=((r->encoding)
264        ?create(buf,s,r->encoding)
265        :create(buf,s,r->encodetype));
266        }else
267    {
268      retval=((r->encoding)
269        ?create(0,0,r->encoding)
270        :create(0,0,r->encodetype));
271    }
272  }else
273  {
274    retval=create(xbuf,bufsize,XUTF8);
275  }
276  return retval;
277}
278
279#if HAS_ICONV
280/* This template works around incompatible iconv protoypes */
281template<typename _T> inline size_t 
282iconv_adaptor(size_t(*iconv_func)(iconv_t, _T, size_t *, char**, size_t*),
283              iconv_t cd, char **inbuf, size_t *inbytesleft,
284              char **outbuf, size_t *outbytesleft)
285{
286  return iconv_func (cd, (_T)inbuf, inbytesleft, outbuf, outbytesleft);
287}
288#endif
289
290GP<GStringRep>
291GStringRep::Unicode::create(
292  void const * const xbuf,
293  unsigned int bufsize,
294  GP<GStringRep> encoding)
295{
296  GP<GStringRep> retval;
297  GStringRep *e=encoding;
298  if(e)
299  {
300    e=(encoding=e->upcase());
301  }
302  if(!e || !e->size)
303  {
304    retval=create(xbuf,bufsize,XOTHER);
305  }else if(!e->cmp("UTF8") || !e->cmp("UTF-8"))
306  {
307    retval=create(xbuf,bufsize,XUTF8);
308  }else if(!e->cmp("UTF16")|| !e->cmp("UTF-16")
309    || !e->cmp("UCS2") || !e->cmp("UCS2"))
310  {
311    retval=create(xbuf,bufsize,XUTF16);
312  }else if(!e->cmp("UCS4") || !e->cmp("UCS-4"))
313  {
314    retval=create(xbuf,bufsize,XUCS4);
315  }else
316  {
317#if HAS_ICONV
318    EncodeType t=XOTHER;
319    void const * const buf=checkmarks(xbuf,bufsize,t); 
320    if(t != XOTHER)
321    {
322      retval=create(xbuf,bufsize,t);
323    }else if(buf && bufsize)
324    {
325      unsigned char const *eptr=(unsigned char *)buf;
326      unsigned int j=0;
327      for(j=0;(j<bufsize)&&*eptr;j++,eptr++)
328        EMPTY_LOOP;
329      if (j)
330      {
331        unsigned char const *ptr=(unsigned char *)buf;
332        if(e)
333        {
334          iconv_t cv=iconv_open("UTF-8",(const char *)e);
335          if(cv == (iconv_t)(-1))
336          { 
337            const int i=e->search('-');
338            if(i>=0)
339            {
340              cv=iconv_open("UTF-8",e->data+i+1);
341            }
342          }
343          if(cv == (iconv_t)(-1))
344          { 
345            retval=create(0,0,XOTHER);
346          }else
347          {
348            size_t ptrleft=(eptr-ptr); 
349            char *utf8buf;
350            size_t pleft=6*ptrleft+1;
351            GPBuffer<char> gutf8buf(utf8buf,pleft);
352            char *p=utf8buf;
353            unsigned char const *last=ptr;
354            for(;iconv_adaptor(iconv, cv, (char**)&ptr, &ptrleft, &p, &pleft);last=ptr) 
355              EMPTY_LOOP;
356            iconv_close(cv);
357            retval=create(utf8buf,(size_t)last-(size_t)buf,t);
358            retval->set_remainder(last,(size_t)eptr-(size_t)last,e);
359          }
360        }
361      }else
362      {
363        retval=create(0,0,XOTHER);
364        retval->set_remainder(0,0,e);
365      }
366    }
367#else
368    retval=create(xbuf,bufsize,XOTHER);
369#endif
370  }
371  return retval;
372}
373
374GP<GStringRep>
375GStringRep::Unicode::create(
376  void const * const xbuf,
377  unsigned int bufsize,
378  EncodeType t)
379{
380  GP<GStringRep> gretval;
381  GStringRep *retval=0;
382  void const * const buf=checkmarks(xbuf,bufsize,t); 
383  if(buf && bufsize)
384  {
385    unsigned char const *eptr=(unsigned char *)buf;
386    unsigned int maxutf8size=0;
387    void const* const xeptr=(void const *)((size_t)eptr+bufsize);
388    switch(t)
389    {
390      case XUCS4:
391      case XUCS4BE:
392      case XUCS4LE:
393      case XUCS4_2143:
394      case XUCS4_3412:
395      {
396        for(unsigned long w;
397          (eptr<xeptr)&&(w=*(unsigned long const *)eptr);
398          eptr+=sizeof(unsigned long))
399        {
400          maxutf8size+=(w>0x7f)?6:1;
401        }
402        break;
403      }
404      case XUTF16:
405      case XUTF16BE:
406      case XUTF16LE:
407      {
408        for(unsigned short w;
409          (eptr<xeptr)&&(w=*(unsigned short const *)eptr);
410          eptr+=sizeof(unsigned short))
411        {
412          maxutf8size+=3;
413        }
414        break;
415      }
416      case XUTF8:
417        for(;(eptr<xeptr)&&*eptr;maxutf8size++,eptr++)
418          EMPTY_LOOP;
419        break;
420      case XEBCDIC:
421        for(;(eptr<xeptr)&&*eptr;eptr++)
422        {
423          maxutf8size+=(*eptr>0x7f)?2:1;
424        }
425        break;
426      default:
427        break;
428    }
429    unsigned char *utf8buf=0;
430    GPBuffer<unsigned char> gutf8buf(utf8buf,maxutf8size+1);
431    utf8buf[0]=0;
432    if (maxutf8size)
433    {
434      unsigned char *optr=utf8buf;
435      int len=0;
436      unsigned char const *iptr=(unsigned char *)buf;
437      unsigned long w;
438      switch(t)
439      {
440        case XUCS4:
441          for(;
442            (iptr<eptr)&&(w=*(unsigned long const *)iptr);
443            len++,iptr+=sizeof(unsigned long const))
444          {
445            optr=UCS4toUTF8(w,optr);
446          }
447          break;
448        case XUCS4BE:
449          for(;(w=UCS4BEtoUCS4(iptr,eptr));len++)
450          {
451            optr=UCS4toUTF8(w,optr);
452          }
453          break;
454        case XUCS4LE:
455          for(;(w=UCS4LEtoUCS4(iptr,eptr));len++)
456          {
457            optr=UCS4toUTF8(w,optr);
458          }
459          break;
460        case XUCS4_2143:
461          for(;(w=UCS4_2143toUCS4(iptr,eptr));len++)
462          {
463            optr=UCS4toUTF8(w,optr);
464          }
465          break;
466        case XUCS4_3412:
467          for(;(w=UCS4_3412toUCS4(iptr,eptr));len++)
468          {
469            optr=UCS4toUTF8(w,optr);
470          }
471          break;
472        case XUTF16:
473          for(;
474            (w=xUTF16toUCS4((unsigned short const*&)iptr,eptr));
475            len++)
476          {
477            optr=UCS4toUTF8(w,optr);
478          }
479          break;
480        case XUTF16BE:
481          for(;(w=UTF16BEtoUCS4(iptr,eptr));len++)
482          {
483            optr=UCS4toUTF8(w,optr);
484          }
485          break;
486        case XUTF16LE:
487          for(;(w=UTF16LEtoUCS4(iptr,eptr));len++)
488          {
489            optr=UCS4toUTF8(w,optr);
490          }
491          break;
492        case XUTF8:
493          for(;(w=UTF8toUCS4(iptr,eptr));len++)
494          {
495            optr=UCS4toUTF8(w,optr);
496          }
497          break;
498        case XEBCDIC:
499          for(;(iptr<eptr)&&(w=*iptr++);len++)
500          {
501            optr=UCS4toUTF8(w,optr);
502          }
503          break;
504        default:
505          break;
506      }
507      const unsigned int size=(size_t)optr-(size_t)utf8buf;
508      if(size)
509      {
510                  retval=(gretval=GStringRep::Unicode::create(size));
511        memcpy(retval->data,utf8buf,size);
512      }else
513      {
514                  retval=(gretval=GStringRep::Unicode::create(1));
515        retval->size=size;
516      }
517      retval->data[size]=0;
518      gutf8buf.resize(0);
519      const size_t s=(size_t)eptr-(size_t)iptr;
520      retval->set_remainder(iptr,s,t);
521    }
522  }
523  if(!retval)
524  {
525    retval=(gretval=GStringRep::Unicode::create(1));
526    retval->data[0]=0;
527    retval->size=0;
528    retval->set_remainder(0,0,t);
529  }
530  return gretval;
531}
532
533static unsigned long
534xUTF16toUCS4(unsigned short const *&s,void const * const eptr)
535{
536  unsigned long U=0;
537  unsigned short const * const r=s+1;
538  if(r <= eptr)
539  {
540    unsigned long const W1=s[0];
541    if((W1<0xD800)||(W1>0xDFFF))
542    {
543      if((U=W1))
544      {
545        s=r;
546      }
547    }else if(W1<=0xDBFF)
548    {
549      unsigned short const * const rr=r+1;
550      if(rr <= eptr)
551      {
552        unsigned long const W2=s[1];
553        if(((W2>=0xDC00)||(W2<=0xDFFF))&&((U=(0x1000+((W1&0x3ff)<<10))|(W2&0x3ff))))
554        {
555          s=rr;
556        }else
557        {
558          U=(unsigned int)(-1)-W1;
559          s=r;
560        }
561      }
562    }
563  }
564  return U;
565}
566
567static unsigned long
568UTF16BEtoUCS4(unsigned char const *&s,void const * const eptr)
569{
570  unsigned long U=0;
571  unsigned char const * const r=s+2;
572  if(r <= eptr)
573  {
574    unsigned long const C1MSB=s[0];
575    if((C1MSB<0xD8)||(C1MSB>0xDF))
576    {
577      if((U=((C1MSB<<8)|((unsigned long)s[1]))))
578      {
579        s=r;
580      }
581    }else if(C1MSB<=0xDB)
582    {
583      unsigned char const * const rr=r+2;
584      if(rr <= eptr)
585      {
586        unsigned long const C2MSB=s[2];
587        if((C2MSB>=0xDC)||(C2MSB<=0xDF))
588        {
589          U=0x10000+((unsigned long)s[1]<<10)+(unsigned long)s[3]
590            +(((C1MSB<<18)|(C2MSB<<8))&0xc0300);
591          s=rr;
592        }else
593        {
594          U=(unsigned int)(-1)-((C1MSB<<8)|((unsigned long)s[1]));
595          s=r;
596        }
597      }
598    }
599  }
600  return U;
601}
602
603static unsigned long
604UTF16LEtoUCS4(unsigned char const *&s,void const * const eptr)
605{
606  unsigned long U=0;
607  unsigned char const * const r=s+2;
608  if(r <= eptr)
609  {
610    unsigned long const C1MSB=s[1];
611    if((C1MSB<0xD8)||(C1MSB>0xDF))
612    {
613      if((U=((C1MSB<<8)|((unsigned long)s[0]))))
614      {
615        s=r;
616      }
617    }else if(C1MSB<=0xDB)
618    {
619      unsigned char const * const rr=r+2;
620      if(rr <= eptr)
621      {
622        unsigned long const C2MSB=s[3];
623        if((C2MSB>=0xDC)||(C2MSB<=0xDF))
624        {
625          U=0x10000+((unsigned long)s[0]<<10)+(unsigned long)s[2]
626            +(((C1MSB<<18)|(C2MSB<<8))&0xc0300);
627          s=rr;
628        }else
629        {
630          U=(unsigned int)(-1)-((C1MSB<<8)|((unsigned long)s[1]));
631          s=r;
632        }
633      }
634    }
635  }
636  return U;
637}
638
639static unsigned long
640UCS4BEtoUCS4(unsigned char const *&s,void const * const eptr)
641{
642  unsigned long U=0;
643  unsigned char const * const r=s+4;
644  if(r<=eptr)
645  {
646    U=(((((((unsigned long)s[0]<<8)|(unsigned long)s[1])<<8)|(unsigned long)s[2])<<8)|(unsigned long)s[3]);
647    if(U)
648    {
649      s=r;
650    } 
651  }
652  return U;
653}
654
655static unsigned long
656UCS4LEtoUCS4(unsigned char const *&s,void const * const eptr)
657{
658  unsigned long U=0;
659  unsigned char const * const r=s+4;
660  if(r<=eptr)
661  {
662    U=(((((((unsigned long)s[3]<<8)|(unsigned long)s[2])<<8)|(unsigned long)s[1])<<8)|(unsigned long)s[0]);
663    if(U)
664    {
665      s=r;
666    }
667  }
668  return U;
669}
670
671static unsigned long
672UCS4_2143toUCS4(unsigned char const *&s,void const * const eptr)
673{
674  unsigned long U=0;
675  unsigned char const * const r=s+4;
676  if(r<=eptr)
677  {
678    U=(((((((unsigned long)s[1]<<8)|(unsigned long)s[0])<<8)|(unsigned long)s[3])<<8)|(unsigned long)s[2]);
679    if(U)
680    {
681      s=r;
682    }
683  }
684  return U;
685}
686
687static unsigned long
688UCS4_3412toUCS4(unsigned char const *&s,void const * const eptr)
689{
690  unsigned long U=0;
691  unsigned char const * const r=s+4;
692  if(r<=eptr)
693  {
694    U=(((((((unsigned long)s[2]<<8)|(unsigned long)s[3])<<8)|(unsigned long)s[0])<<8)|(unsigned long)s[1]);
695    if(U)
696    {
697      s=r;
698    }
699  }
700  return U;
701}
702
703void
704GStringRep::Unicode::set_remainder( void const * const buf,
705   const unsigned int size, const EncodeType xencodetype )
706{
707  gremainder.resize(size,1);
708  if(size)
709    memcpy(remainder,buf,size);
710  encodetype=xencodetype;
711  encoding=0;
712}
713
714void
715GStringRep::Unicode::set_remainder( void const * const buf,
716   const unsigned int size, const GP<GStringRep> &xencoding )
717{
718  gremainder.resize(size,1);
719  if(size)
720    memcpy(remainder,buf,size);
721  encoding=xencoding;
722  encodetype=XOTHER;
723}
724
725void
726GStringRep::Unicode::set_remainder( const GP<GStringRep::Unicode> &xremainder )
727{
728  if(xremainder)
729  {
730    const int size=xremainder->gremainder;
731    gremainder.resize(size,1);
732    if(size)
733      memcpy(remainder,xremainder->remainder,size);
734    encodetype=xremainder->encodetype;
735  }else
736  {
737    gremainder.resize(0,1);
738    encodetype=XUTF8;
739  }
740}
741
742GP<GStringRep::Unicode>
743GStringRep::Unicode::get_remainder( void ) const
744{
745  return const_cast<GStringRep::Unicode *>(this);
746}
747
748GUTF8String
749GUTF8String::create(void const * const buf,const unsigned int size,
750    const EncodeType encodetype, const GUTF8String &encoding)
751{
752  return encoding.length()
753    ?create(buf,size,encodetype)
754    :create(buf,size,encoding);
755}
756
757GUTF8String
758GUTF8String::create( void const * const buf,
759  unsigned int size, const EncodeType encodetype )
760{
761  GUTF8String retval;
762  retval.init(GStringRep::Unicode::create(buf,size,encodetype));
763  return retval;
764}
765
766GUTF8String
767GUTF8String::create( void const * const buf,
768  const unsigned int size, const GP<GStringRep::Unicode> &remainder)
769{
770  GUTF8String retval;
771  retval.init(GStringRep::Unicode::create(buf,size,remainder));
772  return retval;
773}
774
775GUTF8String
776GUTF8String::create( void const * const buf,
777  const unsigned int size, const GUTF8String &encoding )
778{
779  GUTF8String retval;
780  retval.init(GStringRep::Unicode::create(buf,size,encoding ));
781  return retval;
782}
783
784
785#ifdef HAVE_NAMESPACES
786}
787# ifndef NOT_USING_DJVU_NAMESPACE
788using namespace DJVU;
789# endif
790#endif
Note: See TracBrowser for help on using the repository browser.