• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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