1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (C) 2000-2015, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
8 * file name: ucnvhz.c
9 * encoding: UTF-8
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2000oct16
14 * created by: Ram Viswanadha
15 * 10/31/2000 Ram Implemented offsets logic function
16 *
17 */
18
19 #include "unicode/utypes.h"
20
21 #if !UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION
22
23 #include "cmemory.h"
24 #include "unicode/ucnv.h"
25 #include "unicode/ucnv_cb.h"
26 #include "unicode/uset.h"
27 #include "unicode/utf16.h"
28 #include "ucnv_bld.h"
29 #include "ucnv_cnv.h"
30 #include "ucnv_imp.h"
31
32 #define UCNV_TILDE 0x7E /* ~ */
33 #define UCNV_OPEN_BRACE 0x7B /* { */
34 #define UCNV_CLOSE_BRACE 0x7D /* } */
35 #define SB_ESCAPE "\x7E\x7D"
36 #define DB_ESCAPE "\x7E\x7B"
37 #define TILDE_ESCAPE "\x7E\x7E"
38 #define ESC_LEN 2
39
40
41 #define CONCAT_ESCAPE_MACRO(args, targetIndex,targetLength,strToAppend, err, len,sourceIndex) UPRV_BLOCK_MACRO_BEGIN { \
42 while(len-->0){ \
43 if(targetIndex < targetLength){ \
44 args->target[targetIndex] = (unsigned char) *strToAppend; \
45 if(args->offsets!=NULL){ \
46 *(offsets++) = sourceIndex-1; \
47 } \
48 targetIndex++; \
49 } \
50 else{ \
51 args->converter->charErrorBuffer[(int)args->converter->charErrorBufferLength++] = (unsigned char) *strToAppend; \
52 *err =U_BUFFER_OVERFLOW_ERROR; \
53 } \
54 strToAppend++; \
55 } \
56 } UPRV_BLOCK_MACRO_END
57
58
59 typedef struct{
60 UConverter* gbConverter;
61 int32_t targetIndex;
62 int32_t sourceIndex;
63 UBool isEscapeAppended;
64 UBool isStateDBCS;
65 UBool isTargetUCharDBCS;
66 UBool isEmptySegment;
67 }UConverterDataHZ;
68
69
70 U_CDECL_BEGIN
71 static void U_CALLCONV
_HZOpen(UConverter * cnv,UConverterLoadArgs * pArgs,UErrorCode * errorCode)72 _HZOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){
73 UConverter *gbConverter;
74 if(pArgs->onlyTestIsLoadable) {
75 ucnv_canCreateConverter("GBK", errorCode); /* errorCode carries result */
76 return;
77 }
78 gbConverter = ucnv_open("GBK", errorCode);
79 if(U_FAILURE(*errorCode)) {
80 return;
81 }
82 cnv->toUnicodeStatus = 0;
83 cnv->fromUnicodeStatus= 0;
84 cnv->mode=0;
85 cnv->fromUChar32=0x0000;
86 cnv->extraInfo = uprv_calloc(1, sizeof(UConverterDataHZ));
87 if(cnv->extraInfo != NULL){
88 ((UConverterDataHZ*)cnv->extraInfo)->gbConverter = gbConverter;
89 }
90 else {
91 ucnv_close(gbConverter);
92 *errorCode = U_MEMORY_ALLOCATION_ERROR;
93 return;
94 }
95 }
96
97 static void U_CALLCONV
_HZClose(UConverter * cnv)98 _HZClose(UConverter *cnv){
99 if(cnv->extraInfo != NULL) {
100 ucnv_close (((UConverterDataHZ *) (cnv->extraInfo))->gbConverter);
101 if(!cnv->isExtraLocal) {
102 uprv_free(cnv->extraInfo);
103 }
104 cnv->extraInfo = NULL;
105 }
106 }
107
108 static void U_CALLCONV
_HZReset(UConverter * cnv,UConverterResetChoice choice)109 _HZReset(UConverter *cnv, UConverterResetChoice choice){
110 if(choice<=UCNV_RESET_TO_UNICODE) {
111 cnv->toUnicodeStatus = 0;
112 cnv->mode=0;
113 if(cnv->extraInfo != NULL){
114 ((UConverterDataHZ*)cnv->extraInfo)->isStateDBCS = false;
115 ((UConverterDataHZ*)cnv->extraInfo)->isEmptySegment = false;
116 }
117 }
118 if(choice!=UCNV_RESET_TO_UNICODE) {
119 cnv->fromUnicodeStatus= 0;
120 cnv->fromUChar32=0x0000;
121 if(cnv->extraInfo != NULL){
122 ((UConverterDataHZ*)cnv->extraInfo)->isEscapeAppended = false;
123 ((UConverterDataHZ*)cnv->extraInfo)->targetIndex = 0;
124 ((UConverterDataHZ*)cnv->extraInfo)->sourceIndex = 0;
125 ((UConverterDataHZ*)cnv->extraInfo)->isTargetUCharDBCS = false;
126 }
127 }
128 }
129
130 /**************************************HZ Encoding*************************************************
131 * Rules for HZ encoding
132 *
133 * In ASCII mode, a byte is interpreted as an ASCII character, unless a
134 * '~' is encountered. The character '~' is an escape character. By
135 * convention, it must be immediately followed ONLY by '~', '{' or '\n'
136 * (<LF>), with the following special meaning.
137
138 * 1. The escape sequence '~~' is interpreted as a '~'.
139 * 2. The escape-to-GB sequence '~{' switches the mode from ASCII to GB.
140 * 3. The escape sequence '~\n' is a line-continuation marker to be
141 * consumed with no output produced.
142 * In GB mode, characters are interpreted two bytes at a time as (pure)
143 * GB codes until the escape-from-GB code '~}' is read. This code
144 * switches the mode from GB back to ASCII. (Note that the escape-
145 * from-GB code '~}' ($7E7D) is outside the defined GB range.)
146 *
147 * Source: RFC 1842
148 *
149 * Note that the formal syntax in RFC 1842 is invalid. I assume that the
150 * intended definition of single-byte-segment is as follows (pedberg):
151 * single-byte-segment = single-byte-seq 1*single-byte-char
152 */
153
154
155 static void U_CALLCONV
UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs * args,UErrorCode * err)156 UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
157 UErrorCode* err){
158 char tempBuf[2];
159 const char *mySource = ( char *) args->source;
160 UChar *myTarget = args->target;
161 const char *mySourceLimit = args->sourceLimit;
162 UChar32 targetUniChar = 0x0000;
163 int32_t mySourceChar = 0x0000;
164 UConverterDataHZ* myData=(UConverterDataHZ*)(args->converter->extraInfo);
165 tempBuf[0]=0;
166 tempBuf[1]=0;
167
168 /* Calling code already handles this situation. */
169 /*if ((args->converter == NULL) || (args->targetLimit < args->target) || (mySourceLimit < args->source)){
170 *err = U_ILLEGAL_ARGUMENT_ERROR;
171 return;
172 }*/
173
174 while(mySource< mySourceLimit){
175
176 if(myTarget < args->targetLimit){
177
178 mySourceChar= (unsigned char) *mySource++;
179
180 if(args->converter->mode == UCNV_TILDE) {
181 /* second byte after ~ */
182 args->converter->mode=0;
183 switch(mySourceChar) {
184 case 0x0A:
185 /* no output for ~\n (line-continuation marker) */
186 continue;
187 case UCNV_TILDE:
188 if(args->offsets) {
189 args->offsets[myTarget - args->target]=(int32_t)(mySource - args->source - 2);
190 }
191 *(myTarget++)=(UChar)mySourceChar;
192 myData->isEmptySegment = false;
193 continue;
194 case UCNV_OPEN_BRACE:
195 case UCNV_CLOSE_BRACE:
196 myData->isStateDBCS = (mySourceChar == UCNV_OPEN_BRACE);
197 if (myData->isEmptySegment) {
198 myData->isEmptySegment = false; /* we are handling it, reset to avoid future spurious errors */
199 *err = U_ILLEGAL_ESCAPE_SEQUENCE;
200 args->converter->toUCallbackReason = UCNV_IRREGULAR;
201 args->converter->toUBytes[0] = UCNV_TILDE;
202 args->converter->toUBytes[1] = static_cast<uint8_t>(mySourceChar);
203 args->converter->toULength = 2;
204 args->target = myTarget;
205 args->source = mySource;
206 return;
207 }
208 myData->isEmptySegment = true;
209 continue;
210 default:
211 /* if the first byte is equal to TILDE and the trail byte
212 * is not a valid byte then it is an error condition
213 */
214 /*
215 * Ticket 5691: consistent illegal sequences:
216 * - We include at least the first byte in the illegal sequence.
217 * - If any of the non-initial bytes could be the start of a character,
218 * we stop the illegal sequence before the first one of those.
219 */
220 myData->isEmptySegment = false; /* different error here, reset this to avoid spurious future error */
221 *err = U_ILLEGAL_ESCAPE_SEQUENCE;
222 args->converter->toUBytes[0] = UCNV_TILDE;
223 if( myData->isStateDBCS ?
224 (0x21 <= mySourceChar && mySourceChar <= 0x7e) :
225 mySourceChar <= 0x7f
226 ) {
227 /* The current byte could be the start of a character: Back it out. */
228 args->converter->toULength = 1;
229 --mySource;
230 } else {
231 /* Include the current byte in the illegal sequence. */
232 args->converter->toUBytes[1] = static_cast<uint8_t>(mySourceChar);
233 args->converter->toULength = 2;
234 }
235 args->target = myTarget;
236 args->source = mySource;
237 return;
238 }
239 } else if(myData->isStateDBCS) {
240 if(args->converter->toUnicodeStatus == 0x00){
241 /* lead byte */
242 if(mySourceChar == UCNV_TILDE) {
243 args->converter->mode = UCNV_TILDE;
244 } else {
245 /* add another bit to distinguish a 0 byte from not having seen a lead byte */
246 args->converter->toUnicodeStatus = (uint32_t) (mySourceChar | 0x100);
247 myData->isEmptySegment = false; /* the segment has something, either valid or will produce a different error, so reset this */
248 }
249 continue;
250 }
251 else{
252 /* trail byte */
253 int leadIsOk, trailIsOk;
254 uint32_t leadByte = args->converter->toUnicodeStatus & 0xff;
255 targetUniChar = 0xffff;
256 /*
257 * Ticket 5691: consistent illegal sequences:
258 * - We include at least the first byte in the illegal sequence.
259 * - If any of the non-initial bytes could be the start of a character,
260 * we stop the illegal sequence before the first one of those.
261 *
262 * In HZ DBCS, if the second byte is in the 21..7e range,
263 * we report only the first byte as the illegal sequence.
264 * Otherwise we convert or report the pair of bytes.
265 */
266 leadIsOk = (uint8_t)(leadByte - 0x21) <= (0x7d - 0x21);
267 trailIsOk = (uint8_t)(mySourceChar - 0x21) <= (0x7e - 0x21);
268 if (leadIsOk && trailIsOk) {
269 tempBuf[0] = (char) (leadByte+0x80) ;
270 tempBuf[1] = (char) (mySourceChar+0x80);
271 targetUniChar = ucnv_MBCSSimpleGetNextUChar(myData->gbConverter->sharedData,
272 tempBuf, 2, args->converter->useFallback);
273 mySourceChar= (leadByte << 8) | mySourceChar;
274 } else if (trailIsOk) {
275 /* report a single illegal byte and continue with the following DBCS starter byte */
276 --mySource;
277 mySourceChar = (int32_t)leadByte;
278 } else {
279 /* report a pair of illegal bytes if the second byte is not a DBCS starter */
280 /* add another bit so that the code below writes 2 bytes in case of error */
281 mySourceChar= 0x10000 | (leadByte << 8) | mySourceChar;
282 }
283 args->converter->toUnicodeStatus =0x00;
284 }
285 }
286 else{
287 if(mySourceChar == UCNV_TILDE) {
288 args->converter->mode = UCNV_TILDE;
289 continue;
290 } else if(mySourceChar <= 0x7f) {
291 targetUniChar = (UChar)mySourceChar; /* ASCII */
292 myData->isEmptySegment = false; /* the segment has something valid */
293 } else {
294 targetUniChar = 0xffff;
295 myData->isEmptySegment = false; /* different error here, reset this to avoid spurious future error */
296 }
297 }
298 if(targetUniChar < 0xfffe){
299 if(args->offsets) {
300 args->offsets[myTarget - args->target]=(int32_t)(mySource - args->source - 1-(myData->isStateDBCS));
301 }
302
303 *(myTarget++)=(UChar)targetUniChar;
304 }
305 else /* targetUniChar>=0xfffe */ {
306 if(targetUniChar == 0xfffe){
307 *err = U_INVALID_CHAR_FOUND;
308 }
309 else{
310 *err = U_ILLEGAL_CHAR_FOUND;
311 }
312 if(mySourceChar > 0xff){
313 args->converter->toUBytes[0] = (uint8_t)(mySourceChar >> 8);
314 args->converter->toUBytes[1] = (uint8_t)mySourceChar;
315 args->converter->toULength=2;
316 }
317 else{
318 args->converter->toUBytes[0] = (uint8_t)mySourceChar;
319 args->converter->toULength=1;
320 }
321 break;
322 }
323 }
324 else{
325 *err =U_BUFFER_OVERFLOW_ERROR;
326 break;
327 }
328 }
329
330 args->target = myTarget;
331 args->source = mySource;
332 }
333
334
335 static void U_CALLCONV
UConverter_fromUnicode_HZ_OFFSETS_LOGIC(UConverterFromUnicodeArgs * args,UErrorCode * err)336 UConverter_fromUnicode_HZ_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args,
337 UErrorCode * err){
338 const UChar *mySource = args->source;
339 char *myTarget = args->target;
340 int32_t* offsets = args->offsets;
341 int32_t mySourceIndex = 0;
342 int32_t myTargetIndex = 0;
343 int32_t targetLength = (int32_t)(args->targetLimit - myTarget);
344 int32_t mySourceLength = (int32_t)(args->sourceLimit - args->source);
345 uint32_t targetUniChar = 0x0000;
346 UChar32 mySourceChar = 0x0000;
347 UConverterDataHZ *myConverterData=(UConverterDataHZ*)args->converter->extraInfo;
348 UBool isTargetUCharDBCS = (UBool) myConverterData->isTargetUCharDBCS;
349 UBool oldIsTargetUCharDBCS;
350 int len =0;
351 const char* escSeq=NULL;
352
353 /* Calling code already handles this situation. */
354 /*if ((args->converter == NULL) || (args->targetLimit < myTarget) || (args->sourceLimit < args->source)){
355 *err = U_ILLEGAL_ARGUMENT_ERROR;
356 return;
357 }*/
358 if(args->converter->fromUChar32!=0 && myTargetIndex < targetLength) {
359 goto getTrail;
360 }
361 /*writing the char to the output stream */
362 while (mySourceIndex < mySourceLength){
363 targetUniChar = missingCharMarker;
364 if (myTargetIndex < targetLength){
365
366 mySourceChar = (UChar) mySource[mySourceIndex++];
367
368
369 oldIsTargetUCharDBCS = isTargetUCharDBCS;
370 if(mySourceChar ==UCNV_TILDE){
371 /*concatEscape(args, &myTargetIndex, &targetLength,"\x7E\x7E",err,2,&mySourceIndex);*/
372 len = ESC_LEN;
373 escSeq = TILDE_ESCAPE;
374 CONCAT_ESCAPE_MACRO(args, myTargetIndex, targetLength, escSeq,err,len,mySourceIndex);
375 continue;
376 } else if(mySourceChar <= 0x7f) {
377 targetUniChar = mySourceChar;
378 } else {
379 int32_t length= ucnv_MBCSFromUChar32(myConverterData->gbConverter->sharedData,
380 mySourceChar,&targetUniChar,args->converter->useFallback);
381 /* we can only use lead bytes 21..7D and trail bytes 21..7E */
382 if( length == 2 &&
383 (uint16_t)(targetUniChar - 0xa1a1) <= (0xfdfe - 0xa1a1) &&
384 (uint8_t)(targetUniChar - 0xa1) <= (0xfe - 0xa1)
385 ) {
386 targetUniChar -= 0x8080;
387 } else {
388 targetUniChar = missingCharMarker;
389 }
390 }
391 if (targetUniChar != missingCharMarker){
392 myConverterData->isTargetUCharDBCS = isTargetUCharDBCS = (UBool)(targetUniChar>0x00FF);
393 if(oldIsTargetUCharDBCS != isTargetUCharDBCS || !myConverterData->isEscapeAppended ){
394 /*Shifting from a double byte to single byte mode*/
395 if(!isTargetUCharDBCS){
396 len =ESC_LEN;
397 escSeq = SB_ESCAPE;
398 CONCAT_ESCAPE_MACRO(args, myTargetIndex, targetLength, escSeq,err,len,mySourceIndex);
399 myConverterData->isEscapeAppended = true;
400 }
401 else{ /* Shifting from a single byte to double byte mode*/
402 len =ESC_LEN;
403 escSeq = DB_ESCAPE;
404 CONCAT_ESCAPE_MACRO(args, myTargetIndex, targetLength, escSeq,err,len,mySourceIndex);
405 myConverterData->isEscapeAppended = true;
406
407 }
408 }
409
410 if(isTargetUCharDBCS){
411 if( myTargetIndex <targetLength){
412 myTarget[myTargetIndex++] =(char) (targetUniChar >> 8);
413 if(offsets){
414 *(offsets++) = mySourceIndex-1;
415 }
416 if(myTargetIndex < targetLength){
417 myTarget[myTargetIndex++] =(char) targetUniChar;
418 if(offsets){
419 *(offsets++) = mySourceIndex-1;
420 }
421 }else{
422 args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (char) targetUniChar;
423 *err = U_BUFFER_OVERFLOW_ERROR;
424 }
425 }else{
426 args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] =(char) (targetUniChar >> 8);
427 args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (char) targetUniChar;
428 *err = U_BUFFER_OVERFLOW_ERROR;
429 }
430
431 }else{
432 if( myTargetIndex <targetLength){
433 myTarget[myTargetIndex++] = (char) (targetUniChar );
434 if(offsets){
435 *(offsets++) = mySourceIndex-1;
436 }
437
438 }else{
439 args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = (char) targetUniChar;
440 *err = U_BUFFER_OVERFLOW_ERROR;
441 }
442 }
443
444 }
445 else{
446 /* oops.. the code point is unassigned */
447 /*Handle surrogates */
448 /*check if the char is a First surrogate*/
449 if(U16_IS_SURROGATE(mySourceChar)) {
450 if(U16_IS_SURROGATE_LEAD(mySourceChar)) {
451 args->converter->fromUChar32=mySourceChar;
452 getTrail:
453 /*look ahead to find the trail surrogate*/
454 if(mySourceIndex < mySourceLength) {
455 /* test the following code unit */
456 UChar trail=(UChar) args->source[mySourceIndex];
457 if(U16_IS_TRAIL(trail)) {
458 ++mySourceIndex;
459 mySourceChar=U16_GET_SUPPLEMENTARY(args->converter->fromUChar32, trail);
460 args->converter->fromUChar32=0x00;
461 /* there are no surrogates in GB2312*/
462 *err = U_INVALID_CHAR_FOUND;
463 /* exit this condition tree */
464 } else {
465 /* this is an unmatched lead code unit (1st surrogate) */
466 /* callback(illegal) */
467 *err=U_ILLEGAL_CHAR_FOUND;
468 }
469 } else {
470 /* no more input */
471 *err = U_ZERO_ERROR;
472 }
473 } else {
474 /* this is an unmatched trail code unit (2nd surrogate) */
475 /* callback(illegal) */
476 *err=U_ILLEGAL_CHAR_FOUND;
477 }
478 } else {
479 /* callback(unassigned) for a BMP code point */
480 *err = U_INVALID_CHAR_FOUND;
481 }
482
483 args->converter->fromUChar32=mySourceChar;
484 break;
485 }
486 }
487 else{
488 *err = U_BUFFER_OVERFLOW_ERROR;
489 break;
490 }
491 targetUniChar=missingCharMarker;
492 }
493
494 args->target += myTargetIndex;
495 args->source += mySourceIndex;
496 myConverterData->isTargetUCharDBCS = isTargetUCharDBCS;
497 }
498
499 static void U_CALLCONV
_HZ_WriteSub(UConverterFromUnicodeArgs * args,int32_t offsetIndex,UErrorCode * err)500 _HZ_WriteSub(UConverterFromUnicodeArgs *args, int32_t offsetIndex, UErrorCode *err) {
501 UConverter *cnv = args->converter;
502 UConverterDataHZ *convData=(UConverterDataHZ *) cnv->extraInfo;
503 char *p;
504 char buffer[4];
505 p = buffer;
506
507 if( convData->isTargetUCharDBCS){
508 *p++= UCNV_TILDE;
509 *p++= UCNV_CLOSE_BRACE;
510 convData->isTargetUCharDBCS=false;
511 }
512 *p++= (char)cnv->subChars[0];
513
514 ucnv_cbFromUWriteBytes(args,
515 buffer, (int32_t)(p - buffer),
516 offsetIndex, err);
517 }
518
519 /*
520 * Structure for cloning an HZ converter into a single memory block.
521 */
522 struct cloneHZStruct
523 {
524 UConverter cnv;
525 UConverter subCnv;
526 UConverterDataHZ mydata;
527 };
528
529
530 static UConverter * U_CALLCONV
_HZ_SafeClone(const UConverter * cnv,void * stackBuffer,int32_t * pBufferSize,UErrorCode * status)531 _HZ_SafeClone(const UConverter *cnv,
532 void *stackBuffer,
533 int32_t *pBufferSize,
534 UErrorCode *status)
535 {
536 struct cloneHZStruct * localClone;
537 int32_t size, bufferSizeNeeded = sizeof(struct cloneHZStruct);
538
539 if (U_FAILURE(*status)){
540 return nullptr;
541 }
542
543 if (*pBufferSize == 0){ /* 'preflighting' request - set needed size into *pBufferSize */
544 *pBufferSize = bufferSizeNeeded;
545 return nullptr;
546 }
547
548 localClone = (struct cloneHZStruct *)stackBuffer;
549 /* ucnv.c/ucnv_safeClone() copied the main UConverter already */
550
551 uprv_memcpy(&localClone->mydata, cnv->extraInfo, sizeof(UConverterDataHZ));
552 localClone->cnv.extraInfo = &localClone->mydata;
553 localClone->cnv.isExtraLocal = true;
554
555 /* deep-clone the sub-converter */
556 size = (int32_t)sizeof(UConverter);
557 ((UConverterDataHZ*)localClone->cnv.extraInfo)->gbConverter =
558 ucnv_safeClone(((UConverterDataHZ*)cnv->extraInfo)->gbConverter, &localClone->subCnv, &size, status);
559
560 return &localClone->cnv;
561 }
562
563 static void U_CALLCONV
_HZ_GetUnicodeSet(const UConverter * cnv,const USetAdder * sa,UConverterUnicodeSet which,UErrorCode * pErrorCode)564 _HZ_GetUnicodeSet(const UConverter *cnv,
565 const USetAdder *sa,
566 UConverterUnicodeSet which,
567 UErrorCode *pErrorCode) {
568 /* HZ converts all of ASCII */
569 sa->addRange(sa->set, 0, 0x7f);
570
571 /* add all of the code points that the sub-converter handles */
572 ucnv_MBCSGetFilteredUnicodeSetForUnicode(
573 ((UConverterDataHZ*)cnv->extraInfo)->gbConverter->sharedData,
574 sa, which, UCNV_SET_FILTER_HZ,
575 pErrorCode);
576 }
577 U_CDECL_END
578 static const UConverterImpl _HZImpl={
579
580 UCNV_HZ,
581
582 NULL,
583 NULL,
584
585 _HZOpen,
586 _HZClose,
587 _HZReset,
588
589 UConverter_toUnicode_HZ_OFFSETS_LOGIC,
590 UConverter_toUnicode_HZ_OFFSETS_LOGIC,
591 UConverter_fromUnicode_HZ_OFFSETS_LOGIC,
592 UConverter_fromUnicode_HZ_OFFSETS_LOGIC,
593 NULL,
594
595 NULL,
596 NULL,
597 _HZ_WriteSub,
598 _HZ_SafeClone,
599 _HZ_GetUnicodeSet,
600 NULL,
601 NULL
602 };
603
604 static const UConverterStaticData _HZStaticData={
605 sizeof(UConverterStaticData),
606 "HZ",
607 0,
608 UCNV_IBM,
609 UCNV_HZ,
610 1,
611 4,
612 { 0x1a, 0, 0, 0 },
613 1,
614 false,
615 false,
616 0,
617 0,
618 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, /* reserved */
619
620 };
621
622 const UConverterSharedData _HZData=
623 UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_HZStaticData, &_HZImpl);
624
625 #endif /* #if !UCONFIG_NO_CONVERSION && !UCONFIG_NO_LEGACY_CONVERSION && !UCONFIG_ONLY_HTML_CONVERSION */
626