0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / Resource / Resource_Unicode.cxx
1 // Created on: 1996-09-26
2 // Created by: Arnaud BOUZY
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Resource_ConvertUnicode.hxx>
19 #include <Resource_Manager.hxx>
20 #include <Resource_Unicode.hxx>
21 #include <TCollection_AsciiString.hxx>
22 #include <TCollection_ExtendedString.hxx>
23
24 #define isjis(c) (((c)>=0x21 && (c)<=0x7e))
25 #define iseuc(c) (((c)>=0xa1 && (c)<=0xfe))
26 #define issjis1(c) (((c)>=0x81 && (c)<=0x9f) || ((c)>=0xe0 && (c)<=0xef))
27
28 #define issjis2(c) ((c)>=0x40 && (c)<=0xfc && (c)!=0x7f)
29
30 #define ishankana(c) ((c)>=0xa0 && (c)<=0xdf)
31
32 static inline Standard_Boolean isshift (unsigned char c) { return c >= 0x80; }
33 static inline Standard_Boolean isshift (unsigned int c) { return c >= 0x80 && c <= 0xff; }
34
35 void Resource_Unicode::ConvertSJISToUnicode(const Standard_CString fromstr,TCollection_ExtendedString& tostr)
36 {
37   tostr.Clear();
38
39   unsigned char* currentstr = ((unsigned char*) fromstr);
40   unsigned int pl,ph;
41   // BIG INDIAN USED HERE
42   while(*currentstr != '\0') {
43     if (issjis1(*currentstr)) {
44       
45       ph = ((unsigned int) *currentstr);
46       // Be Carefull with first and second !!
47
48       currentstr++;
49
50       pl =  ((unsigned int) *currentstr);
51       currentstr++;
52       
53       Resource_sjis_to_unicode(&ph,&pl);
54       Standard_ExtCharacter curcar = ((Standard_ExtCharacter) ((ph << 8) | pl));
55       TCollection_ExtendedString curext(curcar);
56       tostr.AssignCat(curext);
57     }
58     else {
59       TCollection_ExtendedString curext(((char) *currentstr));
60       currentstr++;
61       tostr.AssignCat(curext);
62     }
63   }
64 }
65
66
67 void Resource_Unicode::ConvertEUCToUnicode(const Standard_CString fromstr,TCollection_ExtendedString& tostr)
68 {
69   tostr.Clear();
70
71   unsigned char* currentstr = ((unsigned char*) fromstr);
72   unsigned int pl,ph;
73   // BIG INDIAN USED HERE
74   while(*currentstr != '\0') {
75     if (iseuc(*currentstr)) {
76       
77       ph = ((unsigned int) *currentstr);
78       // Be Carefull with first and second !!
79
80       currentstr++;
81
82       pl =  ((unsigned int) *currentstr);
83       currentstr++;
84       
85       Resource_euc_to_unicode(&ph,&pl);
86       Standard_ExtCharacter curcar = ((Standard_ExtCharacter) ((ph << 8) | pl));
87       TCollection_ExtendedString curext(curcar);
88       tostr.AssignCat(curext);
89     }
90     else {
91       TCollection_ExtendedString curext(((char) *currentstr));
92       currentstr++;
93       tostr.AssignCat(curext);
94     }
95   }
96 }
97
98 void Resource_Unicode::ConvertGBToUnicode(const Standard_CString fromstr,TCollection_ExtendedString& tostr)
99 {
100   tostr.Clear();
101
102   unsigned char* currentstr = ((unsigned char*) fromstr);
103   unsigned int pl,ph;
104   // BIG INDIAN USED HERE
105   while(*currentstr != '\0') {
106     if (isshift(*currentstr)) {
107       
108       ph = ((unsigned int) *currentstr);
109       // Be Carefull with first and second !!
110
111       currentstr++;
112
113       pl =  ((unsigned int) *currentstr);
114       currentstr++;
115       
116       Resource_gb_to_unicode(&ph,&pl);
117       Standard_ExtCharacter curcar = ((Standard_ExtCharacter) ((ph << 8) | pl));
118       TCollection_ExtendedString curext(curcar);
119       tostr.AssignCat(curext);
120     }
121     else {
122       TCollection_ExtendedString curext(((char) *currentstr));
123       currentstr++;
124       tostr.AssignCat(curext);
125     }
126   }
127 }
128
129 void Resource_Unicode::ConvertANSIToUnicode(const Standard_CString fromstr,TCollection_ExtendedString& tostr)
130 {
131   tostr.Clear();
132
133   TCollection_ExtendedString curext(fromstr);
134   tostr.AssignCat(curext);
135 }
136
137 Standard_Boolean Resource_Unicode::ConvertUnicodeToSJIS(const TCollection_ExtendedString& fromstr,
138                                                         Standard_PCharacter& tostr,
139                                                         const Standard_Integer maxsize)
140 {
141   Standard_Integer nbtrans = 0;
142   Standard_Integer nbext = 1;
143   Standard_Boolean finished = Standard_False;
144   Standard_ExtCharacter curcar;
145   unsigned int pl,ph;
146   // BIG INDIAN USED HERE
147   
148   while (!finished) {
149     if (nbext > fromstr.Length()) {
150       finished = Standard_True;
151       tostr[nbtrans] = '\0';
152     }
153     else {
154       curcar = fromstr.Value(nbext);
155       nbext++;
156       ph = (((unsigned int) curcar) >> 8) & 0xFF;
157       pl = ((unsigned int) curcar) & 0xFF;
158       Resource_unicode_to_sjis(&ph,&pl);
159       if (issjis1(ph)) {
160         if (nbtrans < (maxsize-3)) {
161           tostr[nbtrans] = ((char) ph);
162           nbtrans++;
163           tostr[nbtrans] =  ((char) pl);
164           nbtrans++;
165         }
166         else {
167           tostr[nbtrans] = '\0';
168           nbtrans = maxsize-1;
169           return Standard_False;
170         }
171       }
172       else {
173         tostr[nbtrans] =  ((char) pl);
174         nbtrans++;
175       }
176       if (nbtrans >= (maxsize - 1)) {
177         tostr[maxsize-1] = '\0';
178         finished = Standard_True;
179         return Standard_False;
180       }
181     }
182   }
183   return Standard_True;
184 }
185           
186 Standard_Boolean Resource_Unicode::ConvertUnicodeToEUC(const TCollection_ExtendedString& fromstr,
187                                                        Standard_PCharacter& tostr,
188                                                        const Standard_Integer maxsize)
189 {
190   Standard_Integer nbtrans = 0;
191   Standard_Integer nbext = 1;
192   Standard_Boolean finished = Standard_False;
193   Standard_ExtCharacter curcar;
194   unsigned int pl,ph;
195   // BIG INDIAN USED HERE
196   
197   while (!finished) {
198     if (nbext > fromstr.Length()) {
199       finished = Standard_True;
200       tostr[nbtrans] = '\0';
201     }
202     else {
203       curcar = fromstr.Value(nbext);
204       nbext++;
205       ph = (((unsigned int) curcar) >> 8) & 0xFF;
206       pl = ((unsigned int) curcar) & 0xFF;
207       Resource_unicode_to_euc(&ph,&pl);
208       if (iseuc(ph)) {
209         if (nbtrans < (maxsize-3)) {
210           tostr[nbtrans] = ((char) ph);
211           nbtrans++;
212           tostr[nbtrans] =  ((char) pl);
213           nbtrans++;
214         }
215         else {
216           tostr[nbtrans-1] = '\0';
217           nbtrans = maxsize-1;
218           return Standard_False;
219         }
220       }
221       else {
222         tostr[nbtrans] =  ((char) pl);
223         nbtrans++;
224       }
225       if (nbtrans >= (maxsize - 1)) {
226         tostr[maxsize-1] = '\0';
227         finished = Standard_True;
228         return Standard_False;
229       }
230     }
231   }
232   return Standard_True;
233 }
234           
235 Standard_Boolean Resource_Unicode::ConvertUnicodeToGB(const TCollection_ExtendedString& fromstr,
236                                                       Standard_PCharacter& tostr,
237                                                       const Standard_Integer maxsize)
238 {
239   Standard_Integer nbtrans = 0;
240   Standard_Integer nbext = 1;
241   Standard_Boolean finished = Standard_False;
242   Standard_ExtCharacter curcar;
243   unsigned int pl,ph;
244   // BIG INDIAN USED HERE
245   
246   while (!finished) {
247     if (nbext > fromstr.Length()) {
248       finished = Standard_True;
249       tostr[nbtrans] = '\0';
250     }
251     else {
252       curcar = fromstr.Value(nbext);
253       nbext++;
254       ph = (((unsigned int) curcar) >> 8) & 0xFF;
255       pl = ((unsigned int) curcar) & 0xFF;
256       Resource_unicode_to_gb(&ph,&pl);
257       if (isshift(ph)) {
258         if (nbtrans < (maxsize-3)) {
259           tostr[nbtrans] = ((char) ph);
260           nbtrans++;
261           tostr[nbtrans] =  ((char) pl);
262           nbtrans++;
263         }
264         else {
265           tostr[nbtrans-1] = '\0';
266           nbtrans = maxsize-1;
267           return Standard_False;
268         }
269       }
270       else {
271         tostr[nbtrans] =  ((char) curcar) & 0xFF;
272         nbtrans++;
273       }
274       if (nbtrans >= (maxsize - 1)) {
275         tostr[maxsize-1] = '\0';
276         finished = Standard_True;
277         return Standard_False;
278       }
279     }
280   }
281   return Standard_True;
282 }
283           
284 Standard_Boolean Resource_Unicode::ConvertUnicodeToANSI(const TCollection_ExtendedString& fromstr,
285                                                         Standard_PCharacter& tostr,
286                                                         const Standard_Integer maxsize)
287 {
288   Standard_Integer nbtrans = 0;
289   Standard_Integer nbext = 1;
290   Standard_Boolean finished = Standard_False;
291   Standard_ExtCharacter curcar;
292   unsigned int pl,ph;
293   // BIG INDIAN USED HERE
294   
295   while (!finished) {
296     if (nbext > fromstr.Length()) {
297       finished = Standard_True;
298       tostr[nbtrans] = '\0';
299     }
300     else {
301       curcar = fromstr.Value(nbext);
302       nbext++;
303       ph = ((unsigned int) curcar) >> 8;
304       pl = ((unsigned int) curcar) & 0xFF;
305       if (ph == 0) {
306         tostr[nbtrans] =  ((char) pl);
307       }
308       else {
309         tostr[nbtrans] =  ' ';
310       }
311       nbtrans++;
312     }
313     if (nbtrans >= (maxsize - 1)) {
314       tostr[maxsize-1] = '\0';
315       finished = Standard_True;
316       return Standard_False;
317     }
318   }
319   return Standard_True;
320 }
321
322 static Standard_Boolean AlreadyRead = Standard_False;
323           
324 static Resource_FormatType& Resource_Current_Format()
325 {
326   static Resource_FormatType theformat = Resource_ANSI;
327   if (!AlreadyRead) {
328     AlreadyRead = Standard_True ;
329     Handle(Resource_Manager) mgr = new Resource_Manager("CharSet");
330     if (mgr->Find("FormatType")) {
331       TCollection_AsciiString form = mgr->Value("FormatType");
332       if (form.IsEqual("SJIS")) {
333         theformat = Resource_SJIS;
334       }
335       else if (form.IsEqual("EUC")) {
336         theformat = Resource_EUC;
337       }
338       else if (form.IsEqual("GB")) {
339         theformat = Resource_GB;
340       }
341       else {
342         theformat = Resource_ANSI;
343       }
344     }
345     else {
346       theformat = Resource_ANSI;
347     }
348   }
349   return theformat;
350 }
351
352 void Resource_Unicode::SetFormat(const Resource_FormatType typecode)
353 {
354   AlreadyRead = Standard_True;
355   Resource_Current_Format() = typecode;
356 }
357
358 Resource_FormatType Resource_Unicode::GetFormat()
359 {
360   return Resource_Current_Format();
361 }
362
363
364 void  Resource_Unicode::ReadFormat()
365 {
366   AlreadyRead = Standard_False;
367   Resource_Unicode::GetFormat();
368 }
369
370 void Resource_Unicode::ConvertFormatToUnicode(const Standard_CString fromstr,
371                                               TCollection_ExtendedString& tostr)
372 {
373   Resource_FormatType theform = Resource_Unicode::GetFormat();
374   switch (theform) {
375   case Resource_SJIS :
376     {
377       ConvertSJISToUnicode(fromstr,tostr);
378       break;
379     }
380   case Resource_EUC :
381     {
382       ConvertEUCToUnicode(fromstr,tostr);
383       break;
384     }
385   case Resource_GB :
386     {
387       ConvertGBToUnicode(fromstr,tostr);
388       break;
389     }
390   case Resource_ANSI :
391     {
392       ConvertANSIToUnicode(fromstr,tostr);
393       break;
394     }
395   }
396 }
397
398 Standard_Boolean Resource_Unicode::ConvertUnicodeToFormat(const TCollection_ExtendedString& fromstr,
399                                                           Standard_PCharacter& tostr,
400                                                           const Standard_Integer maxsize)
401 {
402   Resource_FormatType theform = Resource_Unicode::GetFormat();
403   switch (theform) {
404   case Resource_SJIS :
405     {
406       return ConvertUnicodeToSJIS(fromstr,tostr,maxsize);
407     }
408   case Resource_EUC :
409     {
410       return ConvertUnicodeToEUC(fromstr,tostr,maxsize);
411     }
412   case Resource_GB :
413     {
414       return ConvertUnicodeToGB(fromstr,tostr,maxsize);
415     }
416   case Resource_ANSI :
417     {
418       return ConvertUnicodeToANSI(fromstr,tostr,maxsize);
419     }
420   }
421   return Standard_False;
422 }
423