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