Bug Summary

File:out/../deps/icu-small/source/common/ucnv_ct.cpp
Warning:line 492, column 20
Although the value stored to 'tmpState' is used in the enclosing expression, the value is never actually read from 'tmpState'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ucnv_ct.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/ucnv_ct.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4**********************************************************************
5* Copyright (C) 2010-2015, International Business Machines
6* Corporation and others. All Rights Reserved.
7**********************************************************************
8* file name: ucnv_ct.c
9* encoding: UTF-8
10* tab size: 8 (not used)
11* indentation:4
12*
13* created on: 2010Dec09
14* created by: Michael Ow
15*/
16
17#include "unicode/utypes.h"
18
19#if !UCONFIG_NO_CONVERSION0 && !UCONFIG_NO_LEGACY_CONVERSION0 && !UCONFIG_ONLY_HTML_CONVERSION0
20
21#include "unicode/ucnv.h"
22#include "unicode/uset.h"
23#include "unicode/ucnv_err.h"
24#include "unicode/ucnv_cb.h"
25#include "unicode/utf16.h"
26#include "ucnv_imp.h"
27#include "ucnv_bld.h"
28#include "ucnv_cnv.h"
29#include "ucnvmbcs.h"
30#include "cstring.h"
31#include "cmemory.h"
32
33typedef enum {
34 INVALID = -2,
35 DO_SEARCH = -1,
36
37 COMPOUND_TEXT_SINGLE_0 = 0,
38 COMPOUND_TEXT_SINGLE_1 = 1,
39 COMPOUND_TEXT_SINGLE_2 = 2,
40 COMPOUND_TEXT_SINGLE_3 = 3,
41
42 COMPOUND_TEXT_DOUBLE_1 = 4,
43 COMPOUND_TEXT_DOUBLE_2 = 5,
44 COMPOUND_TEXT_DOUBLE_3 = 6,
45 COMPOUND_TEXT_DOUBLE_4 = 7,
46 COMPOUND_TEXT_DOUBLE_5 = 8,
47 COMPOUND_TEXT_DOUBLE_6 = 9,
48 COMPOUND_TEXT_DOUBLE_7 = 10,
49
50 COMPOUND_TEXT_TRIPLE_DOUBLE = 11,
51
52 IBM_915 = 12,
53 IBM_916 = 13,
54 IBM_914 = 14,
55 IBM_874 = 15,
56 IBM_912 = 16,
57 IBM_913 = 17,
58 ISO_8859_14 = 18,
59 IBM_923 = 19,
60 NUM_OF_CONVERTERS = 20
61} COMPOUND_TEXT_CONVERTERS;
62
63#define SEARCH_LENGTH12 12
64
65static const uint8_t escSeqCompoundText[NUM_OF_CONVERTERS][5] = {
66 /* Single */
67 { 0x1B, 0x2D, 0x41, 0, 0 },
68 { 0x1B, 0x2D, 0x4D, 0, 0 },
69 { 0x1B, 0x2D, 0x46, 0, 0 },
70 { 0x1B, 0x2D, 0x47, 0, 0 },
71
72 /* Double */
73 { 0x1B, 0x24, 0x29, 0x41, 0 },
74 { 0x1B, 0x24, 0x29, 0x42, 0 },
75 { 0x1B, 0x24, 0x29, 0x43, 0 },
76 { 0x1B, 0x24, 0x29, 0x44, 0 },
77 { 0x1B, 0x24, 0x29, 0x47, 0 },
78 { 0x1B, 0x24, 0x29, 0x48, 0 },
79 { 0x1B, 0x24, 0x29, 0x49, 0 },
80
81 /* Triple/Double */
82 { 0x1B, 0x25, 0x47, 0, 0 },
83
84 /*IBM-915*/
85 { 0x1B, 0x2D, 0x4C, 0, 0 },
86 /*IBM-916*/
87 { 0x1B, 0x2D, 0x48, 0, 0 },
88 /*IBM-914*/
89 { 0x1B, 0x2D, 0x44, 0, 0 },
90 /*IBM-874*/
91 { 0x1B, 0x2D, 0x54, 0, 0 },
92 /*IBM-912*/
93 { 0x1B, 0x2D, 0x42, 0, 0 },
94 /* IBM-913 */
95 { 0x1B, 0x2D, 0x43, 0, 0 },
96 /* ISO-8859_14 */
97 { 0x1B, 0x2D, 0x5F, 0, 0 },
98 /* IBM-923 */
99 { 0x1B, 0x2D, 0x62, 0, 0 },
100};
101
102#define ESC_START0x1B 0x1B
103
104#define isASCIIRange(codepoint)((codepoint == 0x0000) || (codepoint == 0x0009) || (codepoint
== 0x000A) || (codepoint >= 0x0020 && codepoint <=
0x007f) || (codepoint >= 0x00A0 && codepoint <=
0x00FF)) \
105 ((codepoint == 0x0000) || (codepoint == 0x0009) || (codepoint == 0x000A) || \
106 (codepoint >= 0x0020 && codepoint <= 0x007f) || (codepoint >= 0x00A0 && codepoint <= 0x00FF))
107
108#define isIBM915(codepoint)((codepoint >= 0x0401 && codepoint <= 0x045F) ||
(codepoint == 0x2116)) \
109 ((codepoint >= 0x0401 && codepoint <= 0x045F) || (codepoint == 0x2116))
110
111#define isIBM916(codepoint)((codepoint >= 0x05D0 && codepoint <= 0x05EA) ||
(codepoint == 0x2017) || (codepoint == 0x203E)) \
112 ((codepoint >= 0x05D0 && codepoint <= 0x05EA) || (codepoint == 0x2017) || (codepoint == 0x203E))
113
114#define isCompoundS3(codepoint)((codepoint == 0x060C) || (codepoint == 0x061B) || (codepoint
== 0x061F) || (codepoint >= 0x0621 && codepoint <=
0x063A) || (codepoint >= 0x0640 && codepoint <=
0x0652) || (codepoint >= 0x0660 && codepoint <=
0x066D) || (codepoint == 0x200B) || (codepoint >= 0x0FE70
&& codepoint <= 0x0FE72) || (codepoint == 0x0FE74
) || (codepoint >= 0x0FE76 && codepoint <= 0x0FEBE
)) \
115 ((codepoint == 0x060C) || (codepoint == 0x061B) || (codepoint == 0x061F) || (codepoint >= 0x0621 && codepoint <= 0x063A) || \
116 (codepoint >= 0x0640 && codepoint <= 0x0652) || (codepoint >= 0x0660 && codepoint <= 0x066D) || (codepoint == 0x200B) || \
117 (codepoint >= 0x0FE70 && codepoint <= 0x0FE72) || (codepoint == 0x0FE74) || (codepoint >= 0x0FE76 && codepoint <= 0x0FEBE))
118
119#define isCompoundS2(codepoint)((codepoint == 0x02BC) || (codepoint == 0x02BD) || (codepoint
>= 0x0384 && codepoint <= 0x03CE) || (codepoint
== 0x2015)) \
120 ((codepoint == 0x02BC) || (codepoint == 0x02BD) || (codepoint >= 0x0384 && codepoint <= 0x03CE) || (codepoint == 0x2015))
121
122#define isIBM914(codepoint)((codepoint == 0x0100) || (codepoint == 0x0101) || (codepoint
== 0x0112) || (codepoint == 0x0113) || (codepoint == 0x0116)
|| (codepoint == 0x0117) || (codepoint == 0x0122) || (codepoint
== 0x0123) || (codepoint >= 0x0128 && codepoint <=
0x012B) || (codepoint == 0x012E) || (codepoint == 0x012F) ||
(codepoint >= 0x0136 && codepoint <= 0x0138) ||
(codepoint == 0x013B) || (codepoint == 0x013C) || (codepoint
== 0x0145) || (codepoint == 0x0146) || (codepoint >= 0x014A
&& codepoint <= 0x014D) || (codepoint == 0x0156) ||
(codepoint == 0x0157) || (codepoint >= 0x0166 && codepoint
<= 0x016B) || (codepoint == 0x0172) || (codepoint == 0x0173
)) \
123 ((codepoint == 0x0100) || (codepoint == 0x0101) || (codepoint == 0x0112) || (codepoint == 0x0113) || (codepoint == 0x0116) || (codepoint == 0x0117) || \
124 (codepoint == 0x0122) || (codepoint == 0x0123) || (codepoint >= 0x0128 && codepoint <= 0x012B) || (codepoint == 0x012E) || (codepoint == 0x012F) || \
125 (codepoint >= 0x0136 && codepoint <= 0x0138) || (codepoint == 0x013B) || (codepoint == 0x013C) || (codepoint == 0x0145) || (codepoint == 0x0146) || \
126 (codepoint >= 0x014A && codepoint <= 0x014D) || (codepoint == 0x0156) || (codepoint == 0x0157) || (codepoint >= 0x0166 && codepoint <= 0x016B) || \
127 (codepoint == 0x0172) || (codepoint == 0x0173))
128
129#define isIBM874(codepoint)((codepoint >= 0x0E01 && codepoint <= 0x0E3A) ||
(codepoint >= 0x0E3F && codepoint <= 0x0E5B)) \
130 ((codepoint >= 0x0E01 && codepoint <= 0x0E3A) || (codepoint >= 0x0E3F && codepoint <= 0x0E5B))
131
132#define isIBM912(codepoint)((codepoint >= 0x0102 && codepoint <= 0x0107) ||
(codepoint >= 0x010C && codepoint <= 0x0111) ||
(codepoint >= 0x0118 && codepoint <= 0x011B) ||
(codepoint == 0x0139) || (codepoint == 0x013A) || (codepoint
== 0x013D) || (codepoint == 0x013E) || (codepoint >= 0x0141
&& codepoint <= 0x0144) || (codepoint == 0x0147) ||
(codepoint == 0x0147) || (codepoint == 0x0150) || (codepoint
== 0x0151) || (codepoint == 0x0154) || (codepoint == 0x0155)
|| (codepoint >= 0x0158 && codepoint <= 0x015B
) || (codepoint == 0x015E) || (codepoint == 0x015F) || (codepoint
>= 0x0160 && codepoint <= 0x0165) || (codepoint
== 0x016E) || (codepoint == 0x016F) || (codepoint == 0x0170)
|| (codepoint == 0x0171) || (codepoint >= 0x0179 &&
codepoint <= 0x017E) || (codepoint == 0x02C7) || (codepoint
== 0x02D8) || (codepoint == 0x02D9) || (codepoint == 0x02DB)
|| (codepoint == 0x02DD)) \
133 ((codepoint >= 0x0102 && codepoint <= 0x0107) || (codepoint >= 0x010C && codepoint <= 0x0111) || (codepoint >= 0x0118 && codepoint <= 0x011B) || \
134 (codepoint == 0x0139) || (codepoint == 0x013A) || (codepoint == 0x013D) || (codepoint == 0x013E) || (codepoint >= 0x0141 && codepoint <= 0x0144) || \
135 (codepoint == 0x0147) || (codepoint == 0x0147) || (codepoint == 0x0150) || (codepoint == 0x0151) || (codepoint == 0x0154) || (codepoint == 0x0155) || \
136 (codepoint >= 0x0158 && codepoint <= 0x015B) || (codepoint == 0x015E) || (codepoint == 0x015F) || (codepoint >= 0x0160 && codepoint <= 0x0165) || \
137 (codepoint == 0x016E) || (codepoint == 0x016F) || (codepoint == 0x0170) || (codepoint == 0x0171) || (codepoint >= 0x0179 && codepoint <= 0x017E) || \
138 (codepoint == 0x02C7) || (codepoint == 0x02D8) || (codepoint == 0x02D9) || (codepoint == 0x02DB) || (codepoint == 0x02DD))
139
140#define isIBM913(codepoint)((codepoint >= 0x0108 && codepoint <= 0x010B) ||
(codepoint == 0x011C) || (codepoint == 0x011D) || (codepoint
== 0x0120) || (codepoint == 0x0121) || (codepoint >= 0x0124
&& codepoint <= 0x0127) || (codepoint == 0x0134) ||
(codepoint == 0x0135) || (codepoint == 0x015C) || (codepoint
== 0x015D) || (codepoint == 0x016C) || (codepoint == 0x016D)
) \
141 ((codepoint >= 0x0108 && codepoint <= 0x010B) || (codepoint == 0x011C) || \
142 (codepoint == 0x011D) || (codepoint == 0x0120) || (codepoint == 0x0121) || \
143 (codepoint >= 0x0124 && codepoint <= 0x0127) || (codepoint == 0x0134) || (codepoint == 0x0135) || \
144 (codepoint == 0x015C) || (codepoint == 0x015D) || (codepoint == 0x016C) || (codepoint == 0x016D))
145
146#define isCompoundS1(codepoint)((codepoint == 0x011E) || (codepoint == 0x011F) || (codepoint
== 0x0130) || (codepoint == 0x0131) || (codepoint >= 0x0218
&& codepoint <= 0x021B)) \
147 ((codepoint == 0x011E) || (codepoint == 0x011F) || (codepoint == 0x0130) || \
148 (codepoint == 0x0131) || (codepoint >= 0x0218 && codepoint <= 0x021B))
149
150#define isISO8859_14(codepoint)((codepoint >= 0x0174 && codepoint <= 0x0177) ||
(codepoint == 0x1E0A) || (codepoint == 0x1E0B) || (codepoint
== 0x1E1E) || (codepoint == 0x1E1F) || (codepoint == 0x1E40)
|| (codepoint == 0x1E41) || (codepoint == 0x1E56) || (codepoint
== 0x1E57) || (codepoint == 0x1E60) || (codepoint == 0x1E61)
|| (codepoint == 0x1E6A) || (codepoint == 0x1E6B) || (codepoint
== 0x1EF2) || (codepoint == 0x1EF3) || (codepoint >= 0x1E80
&& codepoint <= 0x1E85)) \
151 ((codepoint >= 0x0174 && codepoint <= 0x0177) || (codepoint == 0x1E0A) || \
152 (codepoint == 0x1E0B) || (codepoint == 0x1E1E) || (codepoint == 0x1E1F) || \
153 (codepoint == 0x1E40) || (codepoint == 0x1E41) || (codepoint == 0x1E56) || \
154 (codepoint == 0x1E57) || (codepoint == 0x1E60) || (codepoint == 0x1E61) || \
155 (codepoint == 0x1E6A) || (codepoint == 0x1E6B) || (codepoint == 0x1EF2) || \
156 (codepoint == 0x1EF3) || (codepoint >= 0x1E80 && codepoint <= 0x1E85))
157
158#define isIBM923(codepoint)((codepoint == 0x0152) || (codepoint == 0x0153) || (codepoint
== 0x0178) || (codepoint == 0x20AC)) \
159 ((codepoint == 0x0152) || (codepoint == 0x0153) || (codepoint == 0x0178) || (codepoint == 0x20AC))
160
161
162typedef struct{
163 UConverterSharedData *myConverterArray[NUM_OF_CONVERTERS];
164 COMPOUND_TEXT_CONVERTERS state;
165} UConverterDataCompoundText;
166
167/*********** Compound Text Converter Protos ***********/
168U_CDECL_BEGINextern "C" {
169static void U_CALLCONV
170_CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode);
171
172static void U_CALLCONV
173 _CompoundTextClose(UConverter *converter);
174
175static void U_CALLCONV
176_CompoundTextReset(UConverter *converter, UConverterResetChoice choice);
177
178static const char* U_CALLCONV
179_CompoundTextgetName(const UConverter* cnv);
180
181
182static int32_t findNextEsc(const char *source, const char *sourceLimit) {
183 int32_t length = static_cast<int32_t>(sourceLimit - source);
184 int32_t i;
185 for (i = 1; i < length; i++) {
186 if (*(source + i) == 0x1B) {
187 return i;
188 }
189 }
190
191 return length;
192}
193
194static COMPOUND_TEXT_CONVERTERS getState(int codepoint) {
195 COMPOUND_TEXT_CONVERTERS state = DO_SEARCH;
196
197 if (isASCIIRange(codepoint)((codepoint == 0x0000) || (codepoint == 0x0009) || (codepoint
== 0x000A) || (codepoint >= 0x0020 && codepoint <=
0x007f) || (codepoint >= 0x00A0 && codepoint <=
0x00FF))) {
198 state = COMPOUND_TEXT_SINGLE_0;
199 } else if (isIBM912(codepoint)((codepoint >= 0x0102 && codepoint <= 0x0107) ||
(codepoint >= 0x010C && codepoint <= 0x0111) ||
(codepoint >= 0x0118 && codepoint <= 0x011B) ||
(codepoint == 0x0139) || (codepoint == 0x013A) || (codepoint
== 0x013D) || (codepoint == 0x013E) || (codepoint >= 0x0141
&& codepoint <= 0x0144) || (codepoint == 0x0147) ||
(codepoint == 0x0147) || (codepoint == 0x0150) || (codepoint
== 0x0151) || (codepoint == 0x0154) || (codepoint == 0x0155)
|| (codepoint >= 0x0158 && codepoint <= 0x015B
) || (codepoint == 0x015E) || (codepoint == 0x015F) || (codepoint
>= 0x0160 && codepoint <= 0x0165) || (codepoint
== 0x016E) || (codepoint == 0x016F) || (codepoint == 0x0170)
|| (codepoint == 0x0171) || (codepoint >= 0x0179 &&
codepoint <= 0x017E) || (codepoint == 0x02C7) || (codepoint
== 0x02D8) || (codepoint == 0x02D9) || (codepoint == 0x02DB)
|| (codepoint == 0x02DD))) {
200 state = IBM_912;
201 }else if (isIBM913(codepoint)((codepoint >= 0x0108 && codepoint <= 0x010B) ||
(codepoint == 0x011C) || (codepoint == 0x011D) || (codepoint
== 0x0120) || (codepoint == 0x0121) || (codepoint >= 0x0124
&& codepoint <= 0x0127) || (codepoint == 0x0134) ||
(codepoint == 0x0135) || (codepoint == 0x015C) || (codepoint
== 0x015D) || (codepoint == 0x016C) || (codepoint == 0x016D)
)) {
202 state = IBM_913;
203 } else if (isISO8859_14(codepoint)((codepoint >= 0x0174 && codepoint <= 0x0177) ||
(codepoint == 0x1E0A) || (codepoint == 0x1E0B) || (codepoint
== 0x1E1E) || (codepoint == 0x1E1F) || (codepoint == 0x1E40)
|| (codepoint == 0x1E41) || (codepoint == 0x1E56) || (codepoint
== 0x1E57) || (codepoint == 0x1E60) || (codepoint == 0x1E61)
|| (codepoint == 0x1E6A) || (codepoint == 0x1E6B) || (codepoint
== 0x1EF2) || (codepoint == 0x1EF3) || (codepoint >= 0x1E80
&& codepoint <= 0x1E85))) {
204 state = ISO_8859_14;
205 } else if (isIBM923(codepoint)((codepoint == 0x0152) || (codepoint == 0x0153) || (codepoint
== 0x0178) || (codepoint == 0x20AC))) {
206 state = IBM_923;
207 } else if (isIBM874(codepoint)((codepoint >= 0x0E01 && codepoint <= 0x0E3A) ||
(codepoint >= 0x0E3F && codepoint <= 0x0E5B))) {
208 state = IBM_874;
209 } else if (isIBM914(codepoint)((codepoint == 0x0100) || (codepoint == 0x0101) || (codepoint
== 0x0112) || (codepoint == 0x0113) || (codepoint == 0x0116)
|| (codepoint == 0x0117) || (codepoint == 0x0122) || (codepoint
== 0x0123) || (codepoint >= 0x0128 && codepoint <=
0x012B) || (codepoint == 0x012E) || (codepoint == 0x012F) ||
(codepoint >= 0x0136 && codepoint <= 0x0138) ||
(codepoint == 0x013B) || (codepoint == 0x013C) || (codepoint
== 0x0145) || (codepoint == 0x0146) || (codepoint >= 0x014A
&& codepoint <= 0x014D) || (codepoint == 0x0156) ||
(codepoint == 0x0157) || (codepoint >= 0x0166 && codepoint
<= 0x016B) || (codepoint == 0x0172) || (codepoint == 0x0173
))) {
210 state = IBM_914;
211 } else if (isCompoundS2(codepoint)((codepoint == 0x02BC) || (codepoint == 0x02BD) || (codepoint
>= 0x0384 && codepoint <= 0x03CE) || (codepoint
== 0x2015))) {
212 state = COMPOUND_TEXT_SINGLE_2;
213 } else if (isCompoundS3(codepoint)((codepoint == 0x060C) || (codepoint == 0x061B) || (codepoint
== 0x061F) || (codepoint >= 0x0621 && codepoint <=
0x063A) || (codepoint >= 0x0640 && codepoint <=
0x0652) || (codepoint >= 0x0660 && codepoint <=
0x066D) || (codepoint == 0x200B) || (codepoint >= 0x0FE70
&& codepoint <= 0x0FE72) || (codepoint == 0x0FE74
) || (codepoint >= 0x0FE76 && codepoint <= 0x0FEBE
))) {
214 state = COMPOUND_TEXT_SINGLE_3;
215 } else if (isIBM916(codepoint)((codepoint >= 0x05D0 && codepoint <= 0x05EA) ||
(codepoint == 0x2017) || (codepoint == 0x203E))) {
216 state = IBM_916;
217 } else if (isIBM915(codepoint)((codepoint >= 0x0401 && codepoint <= 0x045F) ||
(codepoint == 0x2116))) {
218 state = IBM_915;
219 } else if (isCompoundS1(codepoint)((codepoint == 0x011E) || (codepoint == 0x011F) || (codepoint
== 0x0130) || (codepoint == 0x0131) || (codepoint >= 0x0218
&& codepoint <= 0x021B))) {
220 state = COMPOUND_TEXT_SINGLE_1;
221 }
222
223 return state;
224}
225
226static COMPOUND_TEXT_CONVERTERS findStateFromEscSeq(const char* source, const char* sourceLimit, const uint8_t* toUBytesBuffer, int32_t toUBytesBufferLength, UErrorCode *err) {
227 COMPOUND_TEXT_CONVERTERS state = INVALID;
228 UBool matchFound = FALSE0;
229 int32_t i, n, offset = toUBytesBufferLength;
230
231 for (i = 0; i < NUM_OF_CONVERTERS; i++) {
232 matchFound = TRUE1;
233 for (n = 0; escSeqCompoundText[i][n] != 0; n++) {
234 if (n < toUBytesBufferLength) {
235 if (toUBytesBuffer[n] != escSeqCompoundText[i][n]) {
236 matchFound = FALSE0;
237 break;
238 }
239 } else if ((source + (n - offset)) >= sourceLimit) {
240 *err = U_TRUNCATED_CHAR_FOUND;
241 matchFound = FALSE0;
242 break;
243 } else if (*(source + (n - offset)) != escSeqCompoundText[i][n]) {
244 matchFound = FALSE0;
245 break;
246 }
247 }
248
249 if (matchFound) {
250 break;
251 }
252 }
253
254 if (matchFound) {
255 state = (COMPOUND_TEXT_CONVERTERS)i;
256 }
257
258 return state;
259}
260
261static void U_CALLCONV
262_CompoundTextOpen(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){
263 cnv->extraInfo = uprv_mallocuprv_malloc_71 (sizeof (UConverterDataCompoundText));
264 if (cnv->extraInfo != NULL__null) {
265 UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;
266
267 UConverterNamePieces stackPieces;
268 UConverterLoadArgs stackArgs=UCNV_LOAD_ARGS_INITIALIZER{ (int32_t)sizeof(UConverterLoadArgs), 0, false, false, 0, 0,
__null, __null, __null };
269
270 myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_0] = NULL__null;
271 myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_1] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-s1", &stackPieces, &stackArgs, errorCode);
272 myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_2] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-s2", &stackPieces, &stackArgs, errorCode);
273 myConverterData->myConverterArray[COMPOUND_TEXT_SINGLE_3] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-s3", &stackPieces, &stackArgs, errorCode);
274 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_1] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d1", &stackPieces, &stackArgs, errorCode);
275 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_2] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d2", &stackPieces, &stackArgs, errorCode);
276 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_3] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d3", &stackPieces, &stackArgs, errorCode);
277 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_4] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d4", &stackPieces, &stackArgs, errorCode);
278 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_5] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d5", &stackPieces, &stackArgs, errorCode);
279 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_6] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d6", &stackPieces, &stackArgs, errorCode);
280 myConverterData->myConverterArray[COMPOUND_TEXT_DOUBLE_7] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-d7", &stackPieces, &stackArgs, errorCode);
281 myConverterData->myConverterArray[COMPOUND_TEXT_TRIPLE_DOUBLE] = ucnv_loadSharedDataucnv_loadSharedData_71("icu-internal-compound-t", &stackPieces, &stackArgs, errorCode);
282
283 myConverterData->myConverterArray[IBM_915] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-915_P100-1995", &stackPieces, &stackArgs, errorCode);
284 myConverterData->myConverterArray[IBM_916] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-916_P100-1995", &stackPieces, &stackArgs, errorCode);
285 myConverterData->myConverterArray[IBM_914] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-914_P100-1995", &stackPieces, &stackArgs, errorCode);
286 myConverterData->myConverterArray[IBM_874] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-874_P100-1995", &stackPieces, &stackArgs, errorCode);
287 myConverterData->myConverterArray[IBM_912] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-912_P100-1995", &stackPieces, &stackArgs, errorCode);
288 myConverterData->myConverterArray[IBM_913] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-913_P100-2000", &stackPieces, &stackArgs, errorCode);
289 myConverterData->myConverterArray[ISO_8859_14] = ucnv_loadSharedDataucnv_loadSharedData_71("iso-8859_14-1998", &stackPieces, &stackArgs, errorCode);
290 myConverterData->myConverterArray[IBM_923] = ucnv_loadSharedDataucnv_loadSharedData_71("ibm-923_P100-1998", &stackPieces, &stackArgs, errorCode);
291
292 if (U_FAILURE(*errorCode) || pArgs->onlyTestIsLoadable) {
293 _CompoundTextClose(cnv);
294 return;
295 }
296
297 myConverterData->state = (COMPOUND_TEXT_CONVERTERS)0;
298 } else {
299 *errorCode = U_MEMORY_ALLOCATION_ERROR;
300 }
301}
302
303
304static void U_CALLCONV
305_CompoundTextClose(UConverter *converter) {
306 UConverterDataCompoundText* myConverterData = (UConverterDataCompoundText*)(converter->extraInfo);
307 int32_t i;
308
309 if (converter->extraInfo != NULL__null) {
310 /*close the array of converter pointers and free the memory*/
311 for (i = 0; i < NUM_OF_CONVERTERS; i++) {
312 if (myConverterData->myConverterArray[i] != NULL__null) {
313 ucnv_unloadSharedDataIfReadyucnv_unloadSharedDataIfReady_71(myConverterData->myConverterArray[i]);
314 }
315 }
316
317 uprv_freeuprv_free_71(converter->extraInfo);
318 converter->extraInfo = NULL__null;
319 }
320}
321
322static void U_CALLCONV
323_CompoundTextReset(UConverter *converter, UConverterResetChoice choice) {
324 (void)converter;
325 (void)choice;
326}
327
328static const char* U_CALLCONV
329_CompoundTextgetName(const UConverter* cnv){
330 (void)cnv;
331 return "x11-compound-text";
332}
333
334static void U_CALLCONV
335UConverter_fromUnicode_CompoundText_OFFSETS(UConverterFromUnicodeArgs* args, UErrorCode* err){
336 UConverter *cnv = args->converter;
337 uint8_t *target = (uint8_t *) args->target;
338 const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;
339 const UChar* source = args->source;
340 const UChar* sourceLimit = args->sourceLimit;
341 /* int32_t* offsets = args->offsets; */
342 UChar32 sourceChar;
343 UBool useFallback = cnv->useFallback;
344 uint8_t tmpTargetBuffer[7];
345 int32_t tmpTargetBufferLength = 0;
346 COMPOUND_TEXT_CONVERTERS currentState, tmpState;
347 uint32_t pValue;
348 int32_t pValueLength = 0;
349 int32_t i, n, j;
350
351 UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) cnv->extraInfo;
352
353 currentState = myConverterData->state;
354
355 /* check if the last codepoint of previous buffer was a lead surrogate*/
356 if((sourceChar = cnv->fromUChar32)!=0 && target< targetLimit) {
357 goto getTrail;
358 }
359
360 while( source < sourceLimit){
361 if(target < targetLimit){
362
363 sourceChar = *(source++);
364 /*check if the char is a First surrogate*/
365 if(U16_IS_SURROGATE(sourceChar)(((sourceChar)&0xfffff800)==0xd800)) {
366 if(U16_IS_SURROGATE_LEAD(sourceChar)(((sourceChar)&0x400)==0)) {
367getTrail:
368 /*look ahead to find the trail surrogate*/
369 if(source < sourceLimit) {
370 /* test the following code unit */
371 UChar trail=(UChar) *source;
372 if(U16_IS_TRAIL(trail)(((trail)&0xfffffc00)==0xdc00)) {
373 source++;
374 sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail)(((UChar32)(sourceChar)<<10UL)+(UChar32)(trail)-((0xd800
<<10UL)+0xdc00-0x10000));
375 cnv->fromUChar32=0x00;
376 /* convert this supplementary code point */
377 /* exit this condition tree */
378 } else {
379 /* this is an unmatched lead code unit (1st surrogate) */
380 /* callback(illegal) */
381 *err=U_ILLEGAL_CHAR_FOUND;
382 cnv->fromUChar32=sourceChar;
383 break;
384 }
385 } else {
386 /* no more input */
387 cnv->fromUChar32=sourceChar;
388 break;
389 }
390 } else {
391 /* this is an unmatched trail code unit (2nd surrogate) */
392 /* callback(illegal) */
393 *err=U_ILLEGAL_CHAR_FOUND;
394 cnv->fromUChar32=sourceChar;
395 break;
396 }
397 }
398
399 tmpTargetBufferLength = 0;
400 tmpState = getState(sourceChar);
401
402 if (tmpState != DO_SEARCH && currentState != tmpState) {
403 /* Get escape sequence if necessary */
404 currentState = tmpState;
405 for (i = 0; escSeqCompoundText[currentState][i] != 0; i++) {
406 tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][i];
407 }
408 }
409
410 if (tmpState == DO_SEARCH) {
411 /* Test all available converters */
412 for (i = 1; i < SEARCH_LENGTH12; i++) {
413 pValueLength = ucnv_MBCSFromUChar32ucnv_MBCSFromUChar32_71(myConverterData->myConverterArray[i], sourceChar, &pValue, useFallback);
414 if (pValueLength > 0) {
415 tmpState = (COMPOUND_TEXT_CONVERTERS)i;
416 if (currentState != tmpState) {
417 currentState = tmpState;
418 for (j = 0; escSeqCompoundText[currentState][j] != 0; j++) {
419 tmpTargetBuffer[tmpTargetBufferLength++] = escSeqCompoundText[currentState][j];
420 }
421 }
422 for (n = (pValueLength - 1); n >= 0; n--) {
423 tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));
424 }
425 break;
426 }
427 }
428 } else if (tmpState == COMPOUND_TEXT_SINGLE_0) {
429 tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)sourceChar;
430 } else {
431 pValueLength = ucnv_MBCSFromUChar32ucnv_MBCSFromUChar32_71(myConverterData->myConverterArray[currentState], sourceChar, &pValue, useFallback);
432 if (pValueLength > 0) {
433 for (n = (pValueLength - 1); n >= 0; n--) {
434 tmpTargetBuffer[tmpTargetBufferLength++] = (uint8_t)(pValue >> (n * 8));
435 }
436 }
437 }
438
439 for (i = 0; i < tmpTargetBufferLength; i++) {
440 if (target < targetLimit) {
441 *target++ = tmpTargetBuffer[i];
442 } else {
443 *err = U_BUFFER_OVERFLOW_ERROR;
444 break;
445 }
446 }
447
448 if (*err == U_BUFFER_OVERFLOW_ERROR) {
449 for (; i < tmpTargetBufferLength; i++) {
450 args->converter->charErrorBuffer[args->converter->charErrorBufferLength++] = tmpTargetBuffer[i];
451 }
452 }
453 } else {
454 *err = U_BUFFER_OVERFLOW_ERROR;
455 break;
456 }
457 }
458
459 /*save the state and return */
460 myConverterData->state = currentState;
461 args->source = source;
462 args->target = (char*)target;
463}
464
465
466static void U_CALLCONV
467UConverter_toUnicode_CompoundText_OFFSETS(UConverterToUnicodeArgs *args,
468 UErrorCode* err){
469 const char *mySource = (char *) args->source;
470 UChar *myTarget = args->target;
471 const char *mySourceLimit = args->sourceLimit;
472 const char *tmpSourceLimit = mySourceLimit;
473 uint32_t mySourceChar = 0x0000;
474 COMPOUND_TEXT_CONVERTERS currentState, tmpState;
475 int32_t sourceOffset = 0;
476 UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *) args->converter->extraInfo;
477 UConverterSharedData* savedSharedData = NULL__null;
478
479 UConverterToUnicodeArgs subArgs;
480 int32_t minArgsSize;
481
482 /* set up the subconverter arguments */
483 if(args->size<sizeof(UConverterToUnicodeArgs)) {
484 minArgsSize = args->size;
485 } else {
486 minArgsSize = (int32_t)sizeof(UConverterToUnicodeArgs);
487 }
488
489 uprv_memcpy(&subArgs, args, minArgsSize)do { clang diagnostic push clang diagnostic ignored "-Waddress"
(void)0; (void)0; clang diagnostic pop :: memcpy(&subArgs
, args, minArgsSize); } while (false);
490 subArgs.size = (uint16_t)minArgsSize;
491
492 currentState = tmpState = myConverterData->state;
Although the value stored to 'tmpState' is used in the enclosing expression, the value is never actually read from 'tmpState'
493
494 while(mySource < mySourceLimit){
495 if(myTarget < args->targetLimit){
496 if (args->converter->toULength > 0) {
497 mySourceChar = args->converter->toUBytes[0];
498 } else {
499 mySourceChar = (uint8_t)*mySource;
500 }
501
502 if (mySourceChar == ESC_START0x1B) {
503 tmpState = findStateFromEscSeq(mySource, mySourceLimit, args->converter->toUBytes, args->converter->toULength, err);
504
505 if (*err == U_TRUNCATED_CHAR_FOUND) {
506 for (; mySource < mySourceLimit;) {
507 args->converter->toUBytes[args->converter->toULength++] = *mySource++;
508 }
509 *err = U_ZERO_ERROR;
510 break;
511 } else if (tmpState == INVALID) {
512 if (args->converter->toULength == 0) {
513 mySource++; /* skip over the 0x1b byte */
514 }
515 *err = U_ILLEGAL_CHAR_FOUND;
516 break;
517 }
518
519 if (tmpState != currentState) {
520 currentState = tmpState;
521 }
522
523 sourceOffset = static_cast<int32_t>(uprv_strlen((char*)escSeqCompoundText[currentState]):: strlen((char*)escSeqCompoundText[currentState]) - args->converter->toULength);
524
525 mySource += sourceOffset;
526
527 args->converter->toULength = 0;
528 }
529
530 if (currentState == COMPOUND_TEXT_SINGLE_0) {
531 while (mySource < mySourceLimit) {
532 if (*mySource == ESC_START0x1B) {
533 break;
534 }
535 if (myTarget < args->targetLimit) {
536 *myTarget++ = 0x00ff&(*mySource++);
537 } else {
538 *err = U_BUFFER_OVERFLOW_ERROR;
539 break;
540 }
541 }
542 } else if (mySource < mySourceLimit){
543 sourceOffset = findNextEsc(mySource, mySourceLimit);
544
545 tmpSourceLimit = mySource + sourceOffset;
546
547 subArgs.source = mySource;
548 subArgs.sourceLimit = tmpSourceLimit;
549 subArgs.target = myTarget;
550 savedSharedData = subArgs.converter->sharedData;
551 subArgs.converter->sharedData = myConverterData->myConverterArray[currentState];
552
553 ucnv_MBCSToUnicodeWithOffsetsucnv_MBCSToUnicodeWithOffsets_71(&subArgs, err);
554
555 subArgs.converter->sharedData = savedSharedData;
556
557 mySource = subArgs.source;
558 myTarget = subArgs.target;
559
560 if (U_FAILURE(*err)) {
561 if(*err == U_BUFFER_OVERFLOW_ERROR) {
562 if(subArgs.converter->UCharErrorBufferLength > 0) {
563 uprv_memcpy(args->converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer,do { clang diagnostic push clang diagnostic ignored "-Waddress"
(void)0; (void)0; clang diagnostic pop :: memcpy(args->
converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer
, subArgs.converter->UCharErrorBufferLength); } while (false
)
564 subArgs.converter->UCharErrorBufferLength)do { clang diagnostic push clang diagnostic ignored "-Waddress"
(void)0; (void)0; clang diagnostic pop :: memcpy(args->
converter->UCharErrorBuffer, subArgs.converter->UCharErrorBuffer
, subArgs.converter->UCharErrorBufferLength); } while (false
);
565 }
566 args->converter->UCharErrorBufferLength=subArgs.converter->UCharErrorBufferLength;
567 subArgs.converter->UCharErrorBufferLength = 0;
568 }
569 break;
570 }
571 }
572 } else {
573 *err = U_BUFFER_OVERFLOW_ERROR;
574 break;
575 }
576 }
577 myConverterData->state = currentState;
578 args->target = myTarget;
579 args->source = mySource;
580}
581
582static void U_CALLCONV
583_CompoundText_GetUnicodeSet(const UConverter *cnv,
584 const USetAdder *sa,
585 UConverterUnicodeSet which,
586 UErrorCode *pErrorCode) {
587 UConverterDataCompoundText *myConverterData = (UConverterDataCompoundText *)cnv->extraInfo;
588 int32_t i;
589
590 for (i = 1; i < NUM_OF_CONVERTERS; i++) {
591 ucnv_MBCSGetUnicodeSetForUnicodeucnv_MBCSGetUnicodeSetForUnicode_71(myConverterData->myConverterArray[i], sa, which, pErrorCode);
592 }
593 sa->add(sa->set, 0x0000);
594 sa->add(sa->set, 0x0009);
595 sa->add(sa->set, 0x000A);
596 sa->addRange(sa->set, 0x0020, 0x007F);
597 sa->addRange(sa->set, 0x00A0, 0x00FF);
598}
599U_CDECL_END}
600
601static const UConverterImpl _CompoundTextImpl = {
602
603 UCNV_COMPOUND_TEXT,
604
605 NULL__null,
606 NULL__null,
607
608 _CompoundTextOpen,
609 _CompoundTextClose,
610 _CompoundTextReset,
611
612 UConverter_toUnicode_CompoundText_OFFSETS,
613 UConverter_toUnicode_CompoundText_OFFSETS,
614 UConverter_fromUnicode_CompoundText_OFFSETS,
615 UConverter_fromUnicode_CompoundText_OFFSETS,
616 NULL__null,
617
618 NULL__null,
619 _CompoundTextgetName,
620 NULL__null,
621 NULL__null,
622 _CompoundText_GetUnicodeSet,
623 NULL__null,
624 NULL__null
625};
626
627static const UConverterStaticData _CompoundTextStaticData = {
628 sizeof(UConverterStaticData),
629 "COMPOUND_TEXT",
630 0,
631 UCNV_IBM,
632 UCNV_COMPOUND_TEXT,
633 1,
634 6,
635 { 0xef, 0, 0, 0 },
636 1,
637 FALSE0,
638 FALSE0,
639 0,
640 0,
641 { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
642};
643const UConverterSharedData _CompoundTextData_CompoundTextData_71 =
644 UCNV_IMMUTABLE_SHARED_DATA_INITIALIZER(&_CompoundTextStaticData, &_CompoundTextImpl){ sizeof(UConverterSharedData), ~((uint32_t)0), __null, &
_CompoundTextStaticData, false, false, &_CompoundTextImpl
, 0, { 0, 0, 0, 0, __null, __null, __null, __null, __null, __null
, { 0 }, __null, __null, 0, 0, 0, false, 0, 0, __null, __null
, __null, __null } };
645
646#endif /* #if !UCONFIG_NO_LEGACY_CONVERSION */