1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************
4 * COPYRIGHT:
5 * Copyright (c) 2007-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 ********************************************************************/
8
9 #include "udbgutil.h"
10 #include <string.h>
11 #include "ustr_imp.h"
12 #include "cmemory.h"
13 #include "cstring.h"
14 #include "putilimp.h"
15 #include "unicode/ulocdata.h"
16 #include "unicode/ucnv.h"
17 #include "unicode/unistr.h"
18 #include "cstr.h"
19
20 /*
21 To add a new enum type
22 (For example: UShoeSize with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT)
23
24 0. Make sure that all lines you add are protected with appropriate uconfig guards,
25 such as '#if !UCONFIG_NO_SHOES'.
26 1. udbgutil.h: add UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT
27 ( The subsequent steps involve this file, udbgutil.cpp )
28 2. Find the marker "Add new enum types above this line"
29 3. Before that marker, add a #include of any header file you need.
30 4. Each enum type has three things in this section: a #define, a count_, and an array of Fields.
31 It may help to copy and paste a previous definition.
32 5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters
33 " #define LEN_USHOE 6 "
34 6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW.
35 6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value,
36 that can be helpful for automatically defining the count. Otherwise define it manually.
37 " static const int32_t count_UShoeSize = USHOE_COUNT; "
38 7. Define the field names, in order.
39 " static const Field names_UShoeSize[] = {
40 " FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ),
41 " FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ),
42 " FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ),
43 " };
44 ( The following command was usedfor converting ucol.h into partially correct entities )
45 grep "^[ ]*UCOL" < unicode/ucol.h |
46 sed -e 's%^[ ]*\([A-Z]*\)_\([A-Z_]*\).*% FIELD_NAME_STR( LEN_\1, \1_\2 ),%g'
47 8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType
48 ( UDebugEnumType is an enum, too!)
49 names_UDebugEnumType[] { ...
50 " FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ), "
51 9. Find the function _udbg_enumCount and add the count macro:
52 " COUNT_CASE(UShoeSize)
53 10. Find the function _udbg_enumFields and add the field macro:
54 " FIELD_CASE(UShoeSize)
55 11. verify that your test code, and Java data generation, works properly.
56 */
57
58 /**
59 * Structure representing an enum value
60 */
61 struct Field {
62 int32_t prefix; /**< how many characters to remove in the prefix - i.e. UCHAR_ = 5 */
63 const char *str; /**< The actual string value */
64 int32_t num; /**< The numeric value */
65 };
66
67 /**
68 * Define another field name. Used in an array of Field s
69 * @param y the common prefix length (i.e. 6 for "USHOE_" )
70 * @param x the actual enum value - it will be copied in both string and symbolic form.
71 * @see Field
72 */
73 #define FIELD_NAME_STR(y,x) { y, #x, x }
74
75
76 // TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up.
77 #if !UCONFIG_NO_FORMATTING
78
79 // Calendar
80 #include "unicode/ucal.h"
81
82 // 'UCAL_' = 5
83 #define LEN_UCAL 5 /* UCAL_ */
84 static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT;
85 static const Field names_UCalendarDateFields[] =
86 {
87 FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ),
88 FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ),
89 FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ),
90 FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ),
91 FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ),
92 FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ),
93 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ),
94 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ),
95 FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ),
96 FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ),
97 FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ),
98 FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ),
99 FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ),
100 FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ),
101 FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ),
102 FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ),
103 FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ),
104 FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ),
105 FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ),
106 FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ),
107 FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ),
108 FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ),
109 FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ),
110 };
111
112
113 static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1;
114 static const Field names_UCalendarMonths[] =
115 {
116 FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ),
117 FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ),
118 FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ),
119 FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ),
120 FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ),
121 FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ),
122 FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ),
123 FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ),
124 FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ),
125 FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ),
126 FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ),
127 FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ),
128 FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER)
129 };
130
131 #include "unicode/udat.h"
132
133 #define LEN_UDAT 5 /* "UDAT_" */
134 static const int32_t count_UDateFormatStyle = UDAT_SHORT+1;
135 static const Field names_UDateFormatStyle[] =
136 {
137 FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ),
138 FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ),
139 FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ),
140 FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ),
141 /* end regular */
142 /*
143 * negative enums.. leave out for now.
144 FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ),
145 FIELD_NAME_STR( LEN_UDAT, UDAT_PATTERN ),
146 */
147 };
148
149 #endif
150
151 #include "unicode/uloc.h"
152
153 #define LEN_UAR 12 /* "ULOC_ACCEPT_" */
154 static const int32_t count_UAcceptResult = 3;
155 static const Field names_UAcceptResult[] =
156 {
157 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ),
158 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ),
159 FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ),
160 };
161
162 #if !UCONFIG_NO_COLLATION
163 #include "unicode/ucol.h"
164 #define LEN_UCOL 5 /* UCOL_ */
165 static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT;
166 static const Field names_UColAttributeValue[] = {
167 FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ),
168 FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ),
169 FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ),
170 // FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ),
171 FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ),
172 // gap
173 FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ),
174 // FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ),
175 FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ),
176 FIELD_NAME_STR( LEN_UCOL, UCOL_ON ),
177 // gap
178 FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ),
179 FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ),
180 // gap
181 FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ),
182 FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ),
183 };
184
185 #endif
186
187
188 #if UCONFIG_ENABLE_PLUGINS
189 #include "unicode/icuplug.h"
190
191 #define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */
192 static const int32_t count_UPlugReason = UPLUG_REASON_COUNT;
193 static const Field names_UPlugReason[] = {
194 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ),
195 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ),
196 FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ),
197 };
198
199 #define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */
200 static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT;
201 static const Field names_UPlugLevel[] = {
202 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ),
203 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ),
204 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ),
205 FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ),
206 };
207 #endif
208
209 #define LEN_UDBG 5 /* "UDBG_" */
210 static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT;
211 static const Field names_UDebugEnumType[] =
212 {
213 FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ),
214 #if !UCONFIG_NO_FORMATTING
215 FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ),
216 FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ),
217 FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ),
218 #endif
219 #if UCONFIG_ENABLE_PLUGINS
220 FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ),
221 FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ),
222 #endif
223 FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ),
224 #if !UCONFIG_NO_COLLATION
225 FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ),
226 #endif
227 };
228
229
230 // --- Add new enum types above this line ---
231
232 #define COUNT_CASE(x) case UDBG_##x: return (actual?count_##x:UPRV_LENGTHOF(names_##x));
233 #define COUNT_FAIL_CASE(x) case UDBG_##x: return -1;
234
235 #define FIELD_CASE(x) case UDBG_##x: return names_##x;
236 #define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL;
237
238 // low level
239
240 /**
241 * @param type type of item
242 * @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count
243 */
_udbg_enumCount(UDebugEnumType type,UBool actual)244 static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) {
245 switch(type) {
246 COUNT_CASE(UDebugEnumType)
247 #if !UCONFIG_NO_FORMATTING
248 COUNT_CASE(UCalendarDateFields)
249 COUNT_CASE(UCalendarMonths)
250 COUNT_CASE(UDateFormatStyle)
251 #endif
252 #if UCONFIG_ENABLE_PLUGINS
253 COUNT_CASE(UPlugReason)
254 COUNT_CASE(UPlugLevel)
255 #endif
256 COUNT_CASE(UAcceptResult)
257 #if !UCONFIG_NO_COLLATION
258 COUNT_CASE(UColAttributeValue)
259 #endif
260 // COUNT_FAIL_CASE(UNonExistentEnum)
261 default:
262 return -1;
263 }
264 }
265
_udbg_enumFields(UDebugEnumType type)266 static const Field* _udbg_enumFields(UDebugEnumType type) {
267 switch(type) {
268 FIELD_CASE(UDebugEnumType)
269 #if !UCONFIG_NO_FORMATTING
270 FIELD_CASE(UCalendarDateFields)
271 FIELD_CASE(UCalendarMonths)
272 FIELD_CASE(UDateFormatStyle)
273 #endif
274 #if UCONFIG_ENABLE_PLUGINS
275 FIELD_CASE(UPlugReason)
276 FIELD_CASE(UPlugLevel)
277 #endif
278 FIELD_CASE(UAcceptResult)
279 // FIELD_FAIL_CASE(UNonExistentEnum)
280 #if !UCONFIG_NO_COLLATION
281 FIELD_CASE(UColAttributeValue)
282 #endif
283 default:
284 return NULL;
285 }
286 }
287
288 // implementation
289
udbg_enumCount(UDebugEnumType type)290 int32_t udbg_enumCount(UDebugEnumType type) {
291 return _udbg_enumCount(type, FALSE);
292 }
293
udbg_enumExpectedCount(UDebugEnumType type)294 int32_t udbg_enumExpectedCount(UDebugEnumType type) {
295 return _udbg_enumCount(type, TRUE);
296 }
297
udbg_enumName(UDebugEnumType type,int32_t field)298 const char * udbg_enumName(UDebugEnumType type, int32_t field) {
299 if(field<0 ||
300 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
301 return NULL;
302 } else {
303 const Field *fields = _udbg_enumFields(type);
304 if(fields == NULL) {
305 return NULL;
306 } else {
307 return fields[field].str + fields[field].prefix;
308 }
309 }
310 }
311
udbg_enumArrayValue(UDebugEnumType type,int32_t field)312 int32_t udbg_enumArrayValue(UDebugEnumType type, int32_t field) {
313 if(field<0 ||
314 field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
315 return -1;
316 } else {
317 const Field *fields = _udbg_enumFields(type);
318 if(fields == NULL) {
319 return -1;
320 } else {
321 return fields[field].num;
322 }
323 }
324 }
325
udbg_enumByName(UDebugEnumType type,const char * value)326 int32_t udbg_enumByName(UDebugEnumType type, const char *value) {
327 if(type<0||type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) {
328 return -1; // type out of range
329 }
330 const Field *fields = _udbg_enumFields(type);
331 if (fields != NULL) {
332 for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
333 if(!strcmp(value, fields[field].str + fields[field].prefix)) {
334 return fields[field].num;
335 }
336 }
337 // try with the prefix
338 for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
339 if(!strcmp(value, fields[field].str)) {
340 return fields[field].num;
341 }
342 }
343 }
344 // fail
345 return -1;
346 }
347
348 /* platform info */
349 /**
350 * Print the current platform
351 */
udbg_getPlatform(void)352 U_CAPI const char *udbg_getPlatform(void)
353 {
354 #if U_PLATFORM_USES_ONLY_WIN32_API
355 return "Windows";
356 #elif U_PLATFORM == U_PF_CYGWIN
357 return "Cygwin";
358 #elif U_PLATFORM == U_PF_UNKNOWN
359 return "unknown";
360 #elif U_PLATFORM == U_PF_DARWIN
361 return "Darwin";
362 #elif U_PLATFORM == U_PF_BSD
363 return "BSD";
364 #elif U_PLATFORM == U_PF_QNX
365 return "QNX";
366 #elif U_PLATFORM == U_PF_LINUX
367 return "Linux";
368 #elif U_PLATFORM == U_PF_ANDROID
369 return "Android";
370 #elif U_PLATFORM == U_PF_CLASSIC_MACOS
371 return "MacOS (Classic)";
372 #elif U_PLATFORM == U_PF_OS390
373 return "IBM z";
374 #elif U_PLATFORM == U_PF_OS400
375 return "IBM i";
376 #else
377 return "Other (POSIX-like)";
378 #endif
379 }
380
381 struct USystemParams;
382
383 typedef int32_t U_CALLCONV USystemParameterCallback(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status);
384
385 struct USystemParams {
386 const char *paramName;
387 USystemParameterCallback *paramFunction;
388 const char *paramStr;
389 int32_t paramInt;
390 };
391
392 /* parameter types */
393 U_CAPI int32_t
paramEmpty(const USystemParams *,char * target,int32_t targetCapacity,UErrorCode * status)394 paramEmpty(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
395 if(U_FAILURE(*status))return 0;
396 return u_terminateChars(target, targetCapacity, 0, status);
397 }
398
399 U_CAPI int32_t
paramStatic(const USystemParams * param,char * target,int32_t targetCapacity,UErrorCode * status)400 paramStatic(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) {
401 if(param->paramStr==NULL) return paramEmpty(param,target,targetCapacity,status);
402 if(U_FAILURE(*status))return 0;
403 int32_t len = static_cast<int32_t>(uprv_strlen(param->paramStr));
404 if(target!=NULL) {
405 uprv_strncpy(target,param->paramStr,uprv_min(len,targetCapacity));
406 }
407 return u_terminateChars(target, targetCapacity, len, status);
408 }
409
410 static const char *nullString = "(null)";
411
stringToStringBuffer(char * target,int32_t targetCapacity,const char * str,UErrorCode * status)412 static int32_t stringToStringBuffer(char *target, int32_t targetCapacity, const char *str, UErrorCode *status) {
413 if(str==NULL) str=nullString;
414
415 int32_t len = static_cast<int32_t>(uprv_strlen(str));
416 if (U_SUCCESS(*status)) {
417 if(target!=NULL) {
418 uprv_strncpy(target,str,uprv_min(len,targetCapacity));
419 }
420 } else {
421 const char *s = u_errorName(*status);
422 len = static_cast<int32_t>(uprv_strlen(s));
423 if(target!=NULL) {
424 uprv_strncpy(target,s,uprv_min(len,targetCapacity));
425 }
426 }
427 return u_terminateChars(target, targetCapacity, len, status);
428 }
429
integerToStringBuffer(char * target,int32_t targetCapacity,int32_t n,int32_t radix,UErrorCode * status)430 static int32_t integerToStringBuffer(char *target, int32_t targetCapacity, int32_t n, int32_t radix, UErrorCode *status) {
431 if(U_FAILURE(*status)) return 0;
432 char str[300];
433 T_CString_integerToString(str,n,radix);
434 return stringToStringBuffer(target,targetCapacity,str,status);
435 }
436
437 U_CAPI int32_t
paramInteger(const USystemParams * param,char * target,int32_t targetCapacity,UErrorCode * status)438 paramInteger(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) {
439 if(U_FAILURE(*status))return 0;
440 if(param->paramStr==NULL || param->paramStr[0]=='d') {
441 return integerToStringBuffer(target,targetCapacity,param->paramInt, 10,status);
442 } else if(param->paramStr[0]=='x') {
443 return integerToStringBuffer(target,targetCapacity,param->paramInt, 16,status);
444 } else if(param->paramStr[0]=='o') {
445 return integerToStringBuffer(target,targetCapacity,param->paramInt, 8,status);
446 } else if(param->paramStr[0]=='b') {
447 return integerToStringBuffer(target,targetCapacity,param->paramInt, 2,status);
448 } else {
449 *status = U_INTERNAL_PROGRAM_ERROR;
450 return 0;
451 }
452 }
453
454
455 U_CAPI int32_t
paramCldrVersion(const USystemParams *,char * target,int32_t targetCapacity,UErrorCode * status)456 paramCldrVersion(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
457 if(U_FAILURE(*status))return 0;
458 char str[200]="";
459 UVersionInfo icu;
460
461 ulocdata_getCLDRVersion(icu, status);
462 if(U_SUCCESS(*status)) {
463 u_versionToString(icu, str);
464 return stringToStringBuffer(target,targetCapacity,str,status);
465 } else {
466 return 0;
467 }
468 }
469
470
471 #if !UCONFIG_NO_FORMATTING
472 U_CAPI int32_t
paramTimezoneDefault(const USystemParams *,char * target,int32_t targetCapacity,UErrorCode * status)473 paramTimezoneDefault(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
474 if(U_FAILURE(*status))return 0;
475 UChar buf[100];
476 char buf2[100];
477 int32_t len;
478
479 len = ucal_getDefaultTimeZone(buf, 100, status);
480 if(U_SUCCESS(*status)&&len>0) {
481 u_UCharsToChars(buf, buf2, len+1);
482 return stringToStringBuffer(target,targetCapacity, buf2,status);
483 } else {
484 return 0;
485 }
486 }
487 #endif
488
489 U_CAPI int32_t
paramLocaleDefaultBcp47(const USystemParams *,char * target,int32_t targetCapacity,UErrorCode * status)490 paramLocaleDefaultBcp47(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
491 if(U_FAILURE(*status))return 0;
492 const char *def = uloc_getDefault();
493 return uloc_toLanguageTag(def,target,targetCapacity,FALSE,status);
494 }
495
496
497 /* simple 1-liner param functions */
498 #define STRING_PARAM(func, str) U_CAPI int32_t \
499 func(const USystemParams *, char *target, int32_t targetCapacity, UErrorCode *status) \
500 { return stringToStringBuffer(target,targetCapacity,(str),status); }
501
502 STRING_PARAM(paramIcudataPath, u_getDataDirectory())
503 STRING_PARAM(paramPlatform, udbg_getPlatform())
504 STRING_PARAM(paramLocaleDefault, uloc_getDefault())
505 #if !UCONFIG_NO_CONVERSION
506 STRING_PARAM(paramConverterDefault, ucnv_getDefaultName())
507 #endif
508
509 #if !UCONFIG_NO_FORMATTING
510 STRING_PARAM(paramTimezoneVersion, ucal_getTZDataVersion(status))
511 #endif
512
513 static const USystemParams systemParams[] = {
514 { "copyright", paramStatic, U_COPYRIGHT_STRING,0 },
515 { "product", paramStatic, "icu4c",0 },
516 { "product.full", paramStatic, "International Components for Unicode for C/C++",0 },
517 { "version", paramStatic, U_ICU_VERSION,0 },
518 { "version.unicode", paramStatic, U_UNICODE_VERSION,0 },
519 { "platform.number", paramInteger, "d",U_PLATFORM},
520 { "platform.type", paramPlatform, NULL ,0},
521 { "locale.default", paramLocaleDefault, NULL, 0},
522 { "locale.default.bcp47", paramLocaleDefaultBcp47, NULL, 0},
523 #if !UCONFIG_NO_CONVERSION
524 { "converter.default", paramConverterDefault, NULL, 0},
525 #endif
526 { "icudata.name", paramStatic, U_ICUDATA_NAME, 0},
527 { "icudata.path", paramIcudataPath, NULL, 0},
528
529 { "cldr.version", paramCldrVersion, NULL, 0},
530
531 #if !UCONFIG_NO_FORMATTING
532 { "tz.version", paramTimezoneVersion, NULL, 0},
533 { "tz.default", paramTimezoneDefault, NULL, 0},
534 #endif
535
536 { "cpu.bits", paramInteger, "d", (sizeof(void*))*8},
537 { "cpu.big_endian", paramInteger, "b", U_IS_BIG_ENDIAN},
538 { "os.wchar_width", paramInteger, "d", U_SIZEOF_WCHAR_T},
539 { "os.charset_family", paramInteger, "d", U_CHARSET_FAMILY},
540 #if defined (U_HOST)
541 { "os.host", paramStatic, U_HOST, 0},
542 #endif
543 #if defined (U_BUILD)
544 { "build.build", paramStatic, U_BUILD, 0},
545 #endif
546 #if defined (U_CC)
547 { "build.cc", paramStatic, U_CC, 0},
548 #endif
549 #if defined (U_CXX)
550 { "build.cxx", paramStatic, U_CXX, 0},
551 #endif
552 #if defined (CYGWINMSVC)
553 { "build.cygwinmsvc", paramInteger, "b", 1},
554 #endif
555 { "uconfig.internal_digitlist", paramInteger, "b", 1}, /* always 1 */
556 { "uconfig.have_parseallinput", paramInteger, "b", UCONFIG_HAVE_PARSEALLINPUT},
557
558
559 };
560
561 #define U_SYSPARAM_COUNT UPRV_LENGTHOF(systemParams)
562
udbg_getSystemParameterNameByIndex(int32_t i)563 U_CAPI const char *udbg_getSystemParameterNameByIndex(int32_t i) {
564 if(i>=0 && i < (int32_t)U_SYSPARAM_COUNT) {
565 return systemParams[i].paramName;
566 } else {
567 return NULL;
568 }
569 }
570
571
udbg_getSystemParameterValueByIndex(int32_t i,char * buffer,int32_t bufferCapacity,UErrorCode * status)572 U_CAPI int32_t udbg_getSystemParameterValueByIndex(int32_t i, char *buffer, int32_t bufferCapacity, UErrorCode *status) {
573 if(i>=0 && i< (int32_t)U_SYSPARAM_COUNT) {
574 return systemParams[i].paramFunction(&(systemParams[i]),buffer,bufferCapacity,status);
575 } else {
576 return 0;
577 }
578 }
579
udbg_writeIcuInfo(FILE * out)580 U_CAPI void udbg_writeIcuInfo(FILE *out) {
581 char str[2000];
582 /* todo: API for writing DTD? */
583 fprintf(out, " <icuSystemParams type=\"icu4c\">\n");
584 const char *paramName;
585 for(int32_t i=0;(paramName=udbg_getSystemParameterNameByIndex(i))!=NULL;i++) {
586 UErrorCode status2 = U_ZERO_ERROR;
587 udbg_getSystemParameterValueByIndex(i, str,2000,&status2);
588 if(U_SUCCESS(status2)) {
589 fprintf(out," <param name=\"%s\">%s</param>\n", paramName,str);
590 } else {
591 fprintf(out," <!-- n=\"%s\" ERROR: %s -->\n", paramName, u_errorName(status2));
592 }
593 }
594 fprintf(out, " </icuSystemParams>\n");
595 }
596
597 #define ICU_TRAC_URL "http://bugs.icu-project.org/trac/ticket/"
598 #define CLDR_TRAC_URL "http://unicode.org/cldr/trac/ticket/"
599 #define CLDR_TICKET_PREFIX "cldrbug:"
600
udbg_knownIssueURLFrom(const char * ticket,char * buf)601 U_CAPI char *udbg_knownIssueURLFrom(const char *ticket, char *buf) {
602 if( ticket==NULL ) {
603 return NULL;
604 }
605
606 if( !strncmp(ticket, CLDR_TICKET_PREFIX, strlen(CLDR_TICKET_PREFIX)) ) {
607 strcpy( buf, CLDR_TRAC_URL );
608 strcat( buf, ticket+strlen(CLDR_TICKET_PREFIX) );
609 } else {
610 strcpy( buf, ICU_TRAC_URL );
611 strcat( buf, ticket );
612 }
613 return buf;
614 }
615
616
617 #include <set>
618 #include <map>
619 #include <string>
620 #include <ostream>
621 #include <iostream>
622
623 class KnownIssues {
624 public:
625 KnownIssues();
626 ~KnownIssues();
627 void add(const char *ticket, const char *where, const UChar *msg, UBool *firstForTicket, UBool *firstForWhere);
628 void add(const char *ticket, const char *where, const char *msg, UBool *firstForTicket, UBool *firstForWhere);
629 UBool print();
630 private:
631 std::map< std::string,
632 std::map < std::string, std::set < std::string > > > fTable;
633 };
634
KnownIssues()635 KnownIssues::KnownIssues()
636 : fTable()
637 {
638 }
639
~KnownIssues()640 KnownIssues::~KnownIssues()
641 {
642 }
643
add(const char * ticket,const char * where,const UChar * msg,UBool * firstForTicket,UBool * firstForWhere)644 void KnownIssues::add(const char *ticket, const char *where, const UChar *msg, UBool *firstForTicket, UBool *firstForWhere)
645 {
646 if(fTable.find(ticket) == fTable.end()) {
647 if(firstForTicket!=NULL) *firstForTicket = TRUE;
648 fTable[ticket] = std::map < std::string, std::set < std::string > >();
649 } else {
650 if(firstForTicket!=NULL) *firstForTicket = FALSE;
651 }
652 if(where==NULL) return;
653
654 if(fTable[ticket].find(where) == fTable[ticket].end()) {
655 if(firstForWhere!=NULL) *firstForWhere = TRUE;
656 fTable[ticket][where] = std::set < std::string >();
657 } else {
658 if(firstForWhere!=NULL) *firstForWhere = FALSE;
659 }
660 if(msg==NULL || !*msg) return;
661
662 const icu::UnicodeString ustr(msg);
663
664 fTable[ticket][where].insert(std::string(icu::CStr(ustr)()));
665 }
666
add(const char * ticket,const char * where,const char * msg,UBool * firstForTicket,UBool * firstForWhere)667 void KnownIssues::add(const char *ticket, const char *where, const char *msg, UBool *firstForTicket, UBool *firstForWhere)
668 {
669 if(fTable.find(ticket) == fTable.end()) {
670 if(firstForTicket!=NULL) *firstForTicket = TRUE;
671 fTable[ticket] = std::map < std::string, std::set < std::string > >();
672 } else {
673 if(firstForTicket!=NULL) *firstForTicket = FALSE;
674 }
675 if(where==NULL) return;
676
677 if(fTable[ticket].find(where) == fTable[ticket].end()) {
678 if(firstForWhere!=NULL) *firstForWhere = TRUE;
679 fTable[ticket][where] = std::set < std::string >();
680 } else {
681 if(firstForWhere!=NULL) *firstForWhere = FALSE;
682 }
683 if(msg==NULL || !*msg) return;
684
685 std::string str(msg);
686 fTable[ticket][where].insert(str);
687 }
688
print()689 UBool KnownIssues::print()
690 {
691 if(fTable.empty()) {
692 return FALSE;
693 }
694
695 std::cout << "KNOWN ISSUES" << std::endl;
696 for( std::map< std::string,
697 std::map < std::string, std::set < std::string > > >::iterator i = fTable.begin();
698 i != fTable.end();
699 i++ ) {
700 char URL[1024];
701 std::cout << '#' << (*i).first << " <" << udbg_knownIssueURLFrom( (*i).first.c_str(), URL ) << ">" << std::endl;
702
703 for( std::map< std::string, std::set < std::string > >::iterator ii = (*i).second.begin();
704 ii != (*i).second.end();
705 ii++ ) {
706 std::cout << " " << (*ii).first << std::endl;
707 for ( std::set < std::string >::iterator iii = (*ii).second.begin();
708 iii != (*ii).second.end();
709 iii++ ) {
710 std::cout << " " << '"' << (*iii) << '"' << std::endl;
711 }
712 }
713 }
714 return TRUE;
715 }
716
udbg_knownIssue_openU(void * ptr,const char * ticket,char * where,const UChar * msg,UBool * firstForTicket,UBool * firstForWhere)717 U_CAPI void *udbg_knownIssue_openU(void *ptr, const char *ticket, char *where, const UChar *msg, UBool *firstForTicket,
718 UBool *firstForWhere) {
719 KnownIssues *t = static_cast<KnownIssues*>(ptr);
720 if(t==NULL) {
721 t = new KnownIssues();
722 }
723
724 t->add(ticket, where, msg, firstForTicket, firstForWhere);
725
726 return static_cast<void*>(t);
727 }
728
udbg_knownIssue_open(void * ptr,const char * ticket,char * where,const char * msg,UBool * firstForTicket,UBool * firstForWhere)729 U_CAPI void *udbg_knownIssue_open(void *ptr, const char *ticket, char *where, const char *msg, UBool *firstForTicket,
730 UBool *firstForWhere) {
731 KnownIssues *t = static_cast<KnownIssues*>(ptr);
732 if(t==NULL) {
733 t = new KnownIssues();
734 }
735
736 t->add(ticket, where, msg, firstForTicket, firstForWhere);
737
738 return static_cast<void*>(t);
739 }
740
udbg_knownIssue_print(void * ptr)741 U_CAPI UBool udbg_knownIssue_print(void *ptr) {
742 KnownIssues *t = static_cast<KnownIssues*>(ptr);
743 if(t==NULL) {
744 return FALSE;
745 } else {
746 t->print();
747 return TRUE;
748 }
749 }
750
udbg_knownIssue_close(void * ptr)751 U_CAPI void udbg_knownIssue_close(void *ptr) {
752 KnownIssues *t = static_cast<KnownIssues*>(ptr);
753 delete t;
754 }
755