source: icXML/icXML-devel/src/icxercesc/util/XML256TableTranscoder.cpp

Last change on this file was 3103, checked in by cameron, 6 years ago

Initial imports for icXML v0.9

File size: 9.0 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18
19// ---------------------------------------------------------------------------
20//  Includes
21// ---------------------------------------------------------------------------
22#include <xercesc/util/BitOps.hpp>
23#include <xercesc/util/TranscodingException.hpp>
24#include <icxercesc/util/XML256TableTranscoder.hpp>
25#include <icxercesc/util/XMLString.hpp>
26#include <string.h>
27
28XERCES_CPP_NAMESPACE_BEGIN
29
30
31// ---------------------------------------------------------------------------
32//  XML256TableTranscoder: Public Destructor
33// ---------------------------------------------------------------------------
34XML256TableTranscoder::~XML256TableTranscoder()
35{
36    // We don't own the tables, we just reference them
37}
38
39
40// ---------------------------------------------------------------------------
41//  XML256TableTranscoder: Implementation of the transcoder API
42// ---------------------------------------------------------------------------
43XMLSize_t
44XML256TableTranscoder::transcodeFrom(const  XMLByte* const       srcData
45                                    , const XMLSize_t            srcCount
46                                    ,       XMLCh* const         toFill
47                                    , const XMLSize_t            maxChars
48                                    ,       XMLSize_t&           bytesEaten
49                                    ,       unsigned char* const charSizes)
50{
51    //
52    //  Calculate the max chars we can do here. Its the lesser of the
53    //  max output chars and the number of chars in the source.
54    //
55    const XMLSize_t countToDo = srcCount < maxChars ? srcCount : maxChars;
56
57    //
58    //  Loop through the count we have to do and map each char via the
59    //  lookup table.
60    //
61    const XMLByte*  srcPtr = srcData;
62    const XMLByte*  endPtr = (srcPtr + countToDo);
63    XMLCh*          outPtr = toFill;
64    while (srcPtr < endPtr)
65    {
66        const XMLCh uniCh = fFromTable[*srcPtr++];
67        if (uniCh != 0xFFFF)
68        {
69            *outPtr++ = uniCh;
70            continue;
71        }
72    }
73
74
75    // Set the bytes eaten
76    bytesEaten = countToDo;
77
78    // Set the character sizes to the fixed size
79    memset(charSizes, 1, countToDo);
80
81    // Return the chars we transcoded
82    return countToDo;
83}
84
85XMLSize_t
86XML256TableTranscoder::transcodeFrom(const  XMLByte* const       srcData
87                                    , const XMLSize_t            srcCount
88                                    ,       XMLCh* const         toFill
89                                    , const XMLSize_t            maxChars
90                                    ,       XMLSize_t&           bytesEaten)
91{
92    //
93    //  Calculate the max chars we can do here. Its the lesser of the
94    //  max output chars and the number of chars in the source.
95    //
96    const XMLSize_t countToDo = srcCount < maxChars ? srcCount : maxChars;
97
98    //
99    //  Loop through the count we have to do and map each char via the
100    //  lookup table.
101    //
102    const XMLByte*  srcPtr = srcData;
103    const XMLByte*  endPtr = (srcPtr + countToDo);
104    XMLCh*          outPtr = toFill;
105    while (srcPtr < endPtr)
106    {
107        const XMLCh uniCh = fFromTable[*srcPtr++];
108        if (uniCh != 0xFFFF)
109        {
110            *outPtr++ = uniCh;
111            continue;
112        }
113    }
114
115
116    // Set the bytes eaten
117    bytesEaten = countToDo;
118
119    // Return the chars we transcoded
120    return countToDo;
121}
122
123XMLSize_t
124XML256TableTranscoder::transcodeFrom
125(
126      const XMLByte* const          srcData
127    , const XMLSize_t               srcCount
128    ,       XMLBuffer &             toFill
129)
130{
131    toFill.reset();
132    toFill.ensureCapacity(srcCount);
133
134    //
135    //  Loop through the count we have to do and map each char via the
136    //  lookup table.
137    //
138    const XMLByte*  srcPtr = srcData;
139    const XMLByte*  endPtr = (srcPtr + srcCount);
140    XMLCh*          outPtr = toFill.getRawBuffer();
141    while (srcPtr < endPtr)
142    {
143        const XMLCh uniCh = fFromTable[*srcPtr++];
144        if (likely(uniCh != 0xFFFF))
145        {
146            *outPtr++ = uniCh;
147            continue;
148        }
149    }
150
151    toFill.setLen(srcCount);
152
153    // Return the chars we transcoded
154    return srcCount;
155}
156
157XMLSize_t
158XML256TableTranscoder::transcodeTo( const   XMLCh* const    srcData
159                                    , const XMLSize_t       srcCount
160                                    ,       XMLByte* const  toFill
161                                    , const XMLSize_t       maxBytes
162                                    ,       XMLSize_t&      charsEaten
163                                    , const UnRepOpts       options)
164{
165    //
166    //  Calculate the max chars we can do here. Its the lesser of the
167    //  max output chars and the number of chars in the source.
168    //
169    const XMLSize_t countToDo = srcCount < maxBytes ? srcCount : maxBytes;
170
171    //
172    //  Loop through the count we have to do and map each char via the
173    //  lookup table.
174    //
175    const XMLCh*    srcPtr = srcData;
176    const XMLCh*    endPtr = (srcPtr + countToDo);
177    XMLByte*        outPtr = toFill;
178    XMLByte         nextOut;
179    while (srcPtr < endPtr)
180    {
181        //
182        //  Get the next src char out to a temp, then do a binary search
183        //  of the 'to' table for this entry.
184        //
185        if ((nextOut = xlatOneTo(*srcPtr))!=0)
186        {
187            *outPtr++ = nextOut;
188            srcPtr++;
189            continue;
190        }
191
192        //
193        //  Its not representable so, according to the options, either
194        //  throw or use the replacement.
195        //
196        if (options == UnRep_Throw)
197        {
198            XMLCh tmpBuf[17];
199            XMLString::binToText((unsigned int)*srcPtr, tmpBuf, 16, 16, getMemoryManager());
200            ThrowXMLwithMemMgr2
201            (
202                TranscodingException
203                , XMLExcepts::Trans_Unrepresentable
204                , tmpBuf
205                , getEncodingName()
206                , getMemoryManager()
207            );
208        }
209
210        // Eat the source char and use the replacement char
211        srcPtr++;
212        *outPtr++ = 0x3F;
213    }
214
215    // Set the chars eaten
216    charsEaten = countToDo;
217
218    // Return the bytes we transcoded
219    return countToDo;
220}
221
222
223bool XML256TableTranscoder::canTranscodeTo(const unsigned int toCheck)
224{
225    return (xlatOneTo(toCheck) != 0);
226}
227
228
229// ---------------------------------------------------------------------------
230//  XML256TableTranscoder: Hidden constructor
231// ---------------------------------------------------------------------------
232XML256TableTranscoder::
233XML256TableTranscoder(  const   XMLCh* const                     encodingName
234                        , const XMLSize_t                        blockSize
235                        , const XMLCh* const                     fromTable
236                        , const XMLTransService::TransRec* const toTable
237                        , const XMLSize_t                        toTableSize
238                        , MemoryManager* const                   manager) :
239
240    XMLTranscoder(encodingName, blockSize, manager)
241    , fFromTable(fromTable)
242    , fToSize(toTableSize)
243    , fToTable(toTable)
244{
245}
246
247
248// ---------------------------------------------------------------------------
249//  XML256TableTranscoder: Private helper methods
250// ---------------------------------------------------------------------------
251XMLByte XML256TableTranscoder::xlatOneTo(const XMLCh toXlat) const
252{
253    XMLSize_t lowOfs = 0;
254    XMLSize_t hiOfs = fToSize - 1;
255    do
256    {
257        // Calc the mid point of the low and high offset.
258        const XMLSize_t midOfs = ((hiOfs - lowOfs) / 2) + lowOfs;
259
260        //
261        //  If our test char is greater than the mid point char, then
262        //  we move up to the upper half. Else we move to the lower
263        //  half. If its equal, then its our guy.
264        //
265        if (toXlat > fToTable[midOfs].intCh)
266        {
267            lowOfs = midOfs;
268        }
269         else if (toXlat < fToTable[midOfs].intCh)
270        {
271            hiOfs = midOfs;
272        }
273         else
274        {
275            return fToTable[midOfs].extCh;
276        }
277    }   while (lowOfs + 1 < hiOfs);
278
279    // Check the high end of the range otherwise the
280    // last item in the table may never be found.
281        if (toXlat == fToTable[hiOfs].intCh)
282        {
283            return fToTable[hiOfs].extCh;
284        }
285
286    return 0;
287}
288
289XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.