[apple/icu.git] / icuSources / tools / toolutil / udbgutil.cpp

/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 2007-2012, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

#include "udbgutil.h"
#include <string.h>
#include "ustr_imp.h"
#include "cstring.h"
#include "putilimp.h"
#include "unicode/ulocdata.h"
#include "unicode/ucnv.h"

/*
To add a new enum type 
      (For example: UShoeSize  with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT)

    1. udbgutil.h:  add  UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT
      ( The subsequent steps involve this file, udbgutil.cpp )
    2. Find the marker "Add new enum types above this line"
    3. Before that marker, add a #include of any header file you need.
    4. Each enum type has three things in this section:  a #define, a count_, and an array of Fields. 
       It may help to copy and paste a previous definition.
    5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters
         " #define LEN_USHOE 6 "   
       6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW.
    6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value, 
        that can be helpful for automatically defining the count. Otherwise define it manually.
        " static const int32_t count_UShoeSize = USHOE_COUNT; "
    7. Define the field names, in order.
        " static const Field names_UShoeSize[] =  {
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ), 
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ), 
        "  FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ), 
        " };
      ( The following command  was usedfor converting ucol.h into partially correct entities )
      grep "^[  ]*UCOL" < unicode/ucol.h  | 
         sed -e 's%^[  ]*\([A-Z]*\)_\([A-Z_]*\).*%   FIELD_NAME_STR( LEN_\1, \1_\2 ),%g' 
    8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType
          ( UDebugEnumType is an enum, too!)
        names_UDebugEnumType[] { ...  
            " FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ),   "
    9. Find the function _udbg_enumCount  and add the count macro:
            " COUNT_CASE(UShoeSize)
   10. Find the function _udbg_enumFields  and add the field macro:
            " FIELD_CASE(UShoeSize)
   11. verify that your test code, and Java data generation, works properly.
*/

/**
 * Structure representing an enum value
 */
struct Field {
    int32_t prefix;   /**< how many characters to remove in the prefix - i.e. UCHAR_ = 5 */
	const char *str;  /**< The actual string value */
	int32_t num;      /**< The numeric value */
};

/**
 * Calculate the size of an array.
 */
#define DBG_ARRAY_COUNT(x) (sizeof(x)/sizeof(x[0]))

/**
 * Define another field name. Used in an array of Field s
 * @param y the common prefix length (i.e. 6 for "USHOE_" )
 * @param x the actual enum value - it will be copied in both string and symbolic form.
 * @see Field
 */
#define FIELD_NAME_STR(y,x)  { y, #x, x }


// TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up.
#if !UCONFIG_NO_FORMATTING

// Calendar
#include "unicode/ucal.h"

// 'UCAL_' = 5
#define LEN_UCAL 5 /* UCAL_ */
static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT;
static const Field names_UCalendarDateFields[] = 
{
    FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ),
    FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ),
};


static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1;
static const Field names_UCalendarMonths[] = 
{
  FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ),
  FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER)
};

#include "unicode/udat.h"

#define LEN_UDAT 5 /* "UDAT_" */
static const int32_t count_UDateFormatStyle = UDAT_SHORT+1;
static const Field names_UDateFormatStyle[] = 
{
        FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ),
        /* end regular */
    /*
     *  negative enums.. leave out for now.
        FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ),
        FIELD_NAME_STR( LEN_UDAT, UDAT_PATTERN ),
     */
};

#endif
 
#include "unicode/uloc.h"

#define LEN_UAR 12 /* "ULOC_ACCEPT_" */
static const int32_t count_UAcceptResult = 3;
static const Field names_UAcceptResult[] = 
{
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ),
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ),
        FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ),
};

#if !UCONFIG_NO_COLLATION
#include "unicode/ucol.h"
#define LEN_UCOL 5 /* UCOL_ */
static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT;
static const Field names_UColAttributeValue[]  = {
   FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ),
//   FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ),
//   FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_ON ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ),
   // gap
   FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ),
   FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ),
};

#endif


#include "unicode/icuplug.h"

#define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */
static const int32_t count_UPlugReason = UPLUG_REASON_COUNT;
static const Field names_UPlugReason[]  = {
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ),
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ),
   FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ),
};

#define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */
static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT;
static const Field names_UPlugLevel[]  = {
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ),
   FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ),
};

#define LEN_UDBG 5 /* "UDBG_" */
static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT;
static const Field names_UDebugEnumType[] = 
{
    FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ),
#if !UCONFIG_NO_FORMATTING
    FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ),
#endif
    FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ),
    FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ),
#if !UCONFIG_NO_COLLATION
    FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ),
#endif
};


// --- Add new enum types above this line ---

#define COUNT_CASE(x)  case UDBG_##x: return (actual?count_##x:DBG_ARRAY_COUNT(names_##x));
#define COUNT_FAIL_CASE(x) case UDBG_##x: return -1;

#define FIELD_CASE(x)  case UDBG_##x: return names_##x;
#define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL;

// low level

/**
 * @param type type of item
 * @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count
 */
static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) {
	switch(type) {
		COUNT_CASE(UDebugEnumType)
#if !UCONFIG_NO_FORMATTING
		COUNT_CASE(UCalendarDateFields)
		COUNT_CASE(UCalendarMonths)
		COUNT_CASE(UDateFormatStyle)
#endif
        COUNT_CASE(UPlugReason)
        COUNT_CASE(UPlugLevel)
        COUNT_CASE(UAcceptResult)
#if !UCONFIG_NO_COLLATION
        COUNT_CASE(UColAttributeValue)
#endif
		// COUNT_FAIL_CASE(UNonExistentEnum)
	default:
		return -1;
	}
}

static const Field* _udbg_enumFields(UDebugEnumType type) {
	switch(type) {
		FIELD_CASE(UDebugEnumType)
#if !UCONFIG_NO_FORMATTING
		FIELD_CASE(UCalendarDateFields)
		FIELD_CASE(UCalendarMonths)
		FIELD_CASE(UDateFormatStyle)
#endif
        FIELD_CASE(UPlugReason)
        FIELD_CASE(UPlugLevel)
        FIELD_CASE(UAcceptResult)
		// FIELD_FAIL_CASE(UNonExistentEnum)
#if !UCONFIG_NO_COLLATION
        FIELD_CASE(UColAttributeValue)
#endif
	default:
		return NULL;
	}
}

// implementation

int32_t  udbg_enumCount(UDebugEnumType type) {
	return _udbg_enumCount(type, FALSE);
}

int32_t  udbg_enumExpectedCount(UDebugEnumType type) {
	return _udbg_enumCount(type, TRUE);
}

const char *  udbg_enumName(UDebugEnumType type, int32_t field) {
	if(field<0 || 
				field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
		return NULL;
	} else {
		const Field *fields = _udbg_enumFields(type);
		if(fields == NULL) {
			return NULL;
		} else {
			return fields[field].str + fields[field].prefix;
		}
	}
}

int32_t  udbg_enumArrayValue(UDebugEnumType type, int32_t field) {
	if(field<0 || 
				field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
		return -1;
	} else {
		const Field *fields = _udbg_enumFields(type);
		if(fields == NULL) {
			return -1;
		} else {
			return fields[field].num;
		}
	}    
}

int32_t udbg_enumByName(UDebugEnumType type, const char *value) {
    if(type<0||type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) {
        return -1; // type out of range
    }
	const Field *fields = _udbg_enumFields(type);
    for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
        if(!strcmp(value, fields[field].str + fields[field].prefix)) {
            return fields[field].num;
        }        
    }
    // try with the prefix
    for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
        if(!strcmp(value, fields[field].str)) {
            return fields[field].num;
        }        
    }
    // fail
    return -1;
}

/* platform info */
/** 
 * Print the current platform 
 */
U_CAPI const char *udbg_getPlatform(void)
{
#if U_PLATFORM_HAS_WIN32_API
    return "Windows";
#elif U_PLATFORM == U_PF_UNKNOWN
    return "unknown";
#elif U_PLATFORM == U_PF_DARWIN
    return "Darwin";
#elif U_PLATFORM == U_PF_QNX
    return "QNX";
#elif U_PLATFORM == U_PF_LINUX
    return "Linux";
#elif U_PLATFORM == U_PF_ANDROID
    return "Android";
#elif U_PLATFORM == U_PF_CLASSIC_MACOS
    return "MacOS (Classic)";
#elif U_PLATFORM == U_PF_OS390
    return "IBM z";
#elif U_PLATFORM == U_PF_OS400
    return "IBM i";
#else
    return "Other (POSIX-like)";
#endif
}

struct USystemParams;

typedef int32_t U_CALLCONV USystemParameterCallback(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status);

struct USystemParams {
  const char *paramName;
  USystemParameterCallback *paramFunction;
  const char *paramStr;
  int32_t paramInt;
};

/* parameter types */
U_CAPI  int32_t
paramEmpty(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(U_FAILURE(*status))return 0;
  return u_terminateChars(target, targetCapacity, 0, status);
}

U_CAPI  int32_t
paramStatic(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(param->paramStr==NULL) return paramEmpty(param,target,targetCapacity,status);
  if(U_FAILURE(*status))return 0;
  int32_t len = uprv_strlen(param->paramStr);
  if(target!=NULL) {
    uprv_strncpy(target,param->paramStr,uprv_min(len,targetCapacity));
  }
  return u_terminateChars(target, targetCapacity, len, status);
}

static const char *nullString = "(null)";

static int32_t stringToStringBuffer(char *target, int32_t targetCapacity, const char *str, UErrorCode *status) {
  if(str==NULL) str=nullString; 

  int32_t len = uprv_strlen(str);
  if (U_SUCCESS(*status)) {
    if(target!=NULL) {
      uprv_strncpy(target,str,uprv_min(len,targetCapacity));
    }
  } else {
    const char *s = u_errorName(*status);
    len = uprv_strlen(s);
    if(target!=NULL) {
      uprv_strncpy(target,s,uprv_min(len,targetCapacity));
    }
  }
  return u_terminateChars(target, targetCapacity, len, status);
}

static int32_t integerToStringBuffer(char *target, int32_t targetCapacity, int32_t n, int32_t radix, UErrorCode *status) {
  if(U_FAILURE(*status)) return 0;
  char str[300];
  T_CString_integerToString(str,n,radix);
  return stringToStringBuffer(target,targetCapacity,str,status);
}

U_CAPI  int32_t
paramInteger(const USystemParams *param, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(U_FAILURE(*status))return 0;
  if(param->paramStr==NULL || param->paramStr[0]=='d') {
    return integerToStringBuffer(target,targetCapacity,param->paramInt, 10,status);
  } else if(param->paramStr[0]=='x') {
    return integerToStringBuffer(target,targetCapacity,param->paramInt, 16,status);
  } else if(param->paramStr[0]=='o') {
    return integerToStringBuffer(target,targetCapacity,param->paramInt, 8,status);
  } else if(param->paramStr[0]=='b') {
    return integerToStringBuffer(target,targetCapacity,param->paramInt, 2,status);
  } else {
    *status = U_INTERNAL_PROGRAM_ERROR;
    return 0;
  }
}


U_CAPI  int32_t
paramCldrVersion(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(U_FAILURE(*status))return 0;
  char str[200]="";
  UVersionInfo icu;

  ulocdata_getCLDRVersion(icu, status);
  if(U_SUCCESS(*status)) {
    u_versionToString(icu, str);
    return stringToStringBuffer(target,targetCapacity,str,status);
  } else {
    return 0;
  }
}


#if !UCONFIG_NO_FORMATTING
U_CAPI  int32_t
paramTimezoneDefault(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(U_FAILURE(*status))return 0;
  UChar buf[100];
  char buf2[100];
  int32_t len;
  
  len = ucal_getDefaultTimeZone(buf, 100, status);
  if(U_SUCCESS(*status)&&len>0) {
    u_UCharsToChars(buf, buf2, len+1);
    return stringToStringBuffer(target,targetCapacity, buf2,status);
  } else {
    return 0;
  }
}
#endif

U_CAPI  int32_t
paramLocaleDefaultBcp47(const USystemParams * /* param */, char *target, int32_t targetCapacity, UErrorCode *status) {
  if(U_FAILURE(*status))return 0;
  const char *def = uloc_getDefault();
  return uloc_toLanguageTag(def,target,targetCapacity,FALSE,status);
}


/* simple 1-liner param functions */
#define STRING_PARAM(func, str) U_CAPI  int32_t \
  func(const USystemParams *, char *target, int32_t targetCapacity, UErrorCode *status) \
  {  return stringToStringBuffer(target,targetCapacity,(str),status); }

STRING_PARAM(paramIcudataPath, u_getDataDirectory())
STRING_PARAM(paramPlatform, udbg_getPlatform())
STRING_PARAM(paramLocaleDefault, uloc_getDefault())
#if !UCONFIG_NO_CONVERSION
STRING_PARAM(paramConverterDefault, ucnv_getDefaultName())
#endif

#if !UCONFIG_NO_FORMATTING
STRING_PARAM(paramTimezoneVersion, ucal_getTZDataVersion(status))
#endif

static const USystemParams systemParams[] = {
  { "copyright",    paramStatic, U_COPYRIGHT_STRING,0 },
  { "product",      paramStatic, "icu4c",0 },
  { "product.full", paramStatic, "International Components for Unicode for C/C++",0 },
  { "version",      paramStatic, U_ICU_VERSION,0 },
  { "version.unicode", paramStatic, U_UNICODE_VERSION,0 },
  { "platform.number", paramInteger, "d",U_PLATFORM},
  { "platform.type", paramPlatform, NULL ,0},
  { "locale.default", paramLocaleDefault, NULL, 0},
  { "locale.default.bcp47", paramLocaleDefaultBcp47, NULL, 0},
#if !UCONFIG_NO_CONVERSION
  { "converter.default", paramConverterDefault, NULL, 0},
#endif
  { "icudata.name", paramStatic, U_ICUDATA_NAME, 0},
  { "icudata.path", paramIcudataPath, NULL, 0},

  { "cldr.version", paramCldrVersion, NULL, 0},
  
#if !UCONFIG_NO_FORMATTING
  { "tz.version", paramTimezoneVersion, NULL, 0},
  { "tz.default", paramTimezoneDefault, NULL, 0},
#endif
  
  { "cpu.bits",       paramInteger, "d", (sizeof(void*))*8},
  { "cpu.big_endian", paramInteger, "b", U_IS_BIG_ENDIAN},
  { "os.wchar_width", paramInteger, "d", U_SIZEOF_WCHAR_T},
  { "os.charset_family", paramInteger, "d", U_CHARSET_FAMILY},
#if defined (U_HOST)
  { "os.host", paramStatic, U_HOST, 0},
#endif
#if defined (U_BUILD)
  { "build.build", paramStatic, U_BUILD, 0},
#endif
#if defined (U_CC)
  { "build.cc", paramStatic, U_CC, 0},
#endif
#if defined (U_CXX)
  { "build.cxx", paramStatic, U_CXX, 0},
#endif
#if defined (CYGWINMSVC)
  { "build.cygwinmsvc", paramInteger, "b", 1},
#endif
  { "uconfig.internal_digitlist", paramInteger, "b", 1}, /* always 1 */
  { "uconfig.have_parseallinput", paramInteger, "b", UCONFIG_HAVE_PARSEALLINPUT},
  { "uconfig.format_fastpaths_49",paramInteger, "b", UCONFIG_FORMAT_FASTPATHS_49},


};

#define U_SYSPARAM_COUNT (sizeof(systemParams)/sizeof(systemParams[0]))

U_CAPI const char *udbg_getSystemParameterNameByIndex(int32_t i) {
  if(i>=0 && i < (int32_t)U_SYSPARAM_COUNT) {
    return systemParams[i].paramName;
  } else {
    return NULL;
  }
}


U_CAPI int32_t udbg_getSystemParameterValueByIndex(int32_t i, char *buffer, int32_t bufferCapacity, UErrorCode *status) {
  if(i>=0 && i< (int32_t)U_SYSPARAM_COUNT) {
    return systemParams[i].paramFunction(&(systemParams[i]),buffer,bufferCapacity,status);
  } else {
    return 0;
  }
}

U_CAPI void udbg_writeIcuInfo(FILE *out) {
  char str[2000];
  /* todo: API for writing DTD? */
  fprintf(out, " <icuSystemParams type=\"icu4c\">\n");
  const char *paramName;
  for(int32_t i=0;(paramName=udbg_getSystemParameterNameByIndex(i))!=NULL;i++) {
    UErrorCode status2 = U_ZERO_ERROR;
    udbg_getSystemParameterValueByIndex(i, str,2000,&status2);
    if(U_SUCCESS(status2)) {
      fprintf(out,"    <param name=\"%s\">%s</param>\n", paramName,str);
    } else {
      fprintf(out,"  <!-- n=\"%s\" ERROR: %s -->\n", paramName, u_errorName(status2));
    }
  }
  fprintf(out, " </icuSystemParams>\n");
}
Commit	Line	Data
729e4ab9 A	1	/********************************************************************
729e4ab9 A	2	* COPYRIGHT:
4388f060	3	* Copyright (c) 2007-2012, 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"
51004dcb	14
729e4ab9 A	15	/*
	16	To add a new enum type
	17	(For example: UShoeSize with values USHOE_WIDE=0, USHOE_REGULAR, USHOE_NARROW, USHOE_COUNT)
	18
	19	1. udbgutil.h: add UDBG_UShoeSize to the UDebugEnumType enum before UDBG_ENUM_COUNT
	20	( The subsequent steps involve this file, udbgutil.cpp )
	21	2. Find the marker "Add new enum types above this line"
	22	3. Before that marker, add a #include of any header file you need.
	23	4. Each enum type has three things in this section: a #define, a count_, and an array of Fields.
	24	It may help to copy and paste a previous definition.
	25	5. In the case of the USHOE_... strings above, "USHOE_" is common to all values- six characters
	26	" #define LEN_USHOE 6 "
	27	6 characters will strip off "USHOE_" leaving enum values of WIDE, REGULAR, and NARROW.
	28	6. Define the 'count_' variable, with the number of enum values. If the enum has a _MAX or _COUNT value,
	29	that can be helpful for automatically defining the count. Otherwise define it manually.
	30	" static const int32_t count_UShoeSize = USHOE_COUNT; "
	31	7. Define the field names, in order.
	32	" static const Field names_UShoeSize[] = {
	33	" FIELD_NAME_STR( LEN_USHOE, USHOE_WIDE ),
	34	" FIELD_NAME_STR( LEN_USHOE, USHOE_REGULAR ),
	35	" FIELD_NAME_STR( LEN_USHOE, USHOE_NARROW ),
	36	" };
	37	( The following command was usedfor converting ucol.h into partially correct entities )
	38	grep "^[ ]*UCOL" < unicode/ucol.h \|
	39	sed -e 's%^[ ]\([A-Z]\)_\([A-Z_]\).% FIELD_NAME_STR( LEN_\1, \1_\2 ),%g'
	40	8. Now, a bit farther down, add the name of the enum itself to the end of names_UDebugEnumType
	41	( UDebugEnumType is an enum, too!)
	42	names_UDebugEnumType[] { ...
	43	" FIELD_NAME_STR( LEN_UDBG, UDBG_UShoeSize ), "
	44	9. Find the function _udbg_enumCount and add the count macro:
	45	" COUNT_CASE(UShoeSize)
	46	10. Find the function _udbg_enumFields and add the field macro:
	47	" FIELD_CASE(UShoeSize)
	48	11. verify that your test code, and Java data generation, works properly.
	49	*/
	50
	51	/**
	52	* Structure representing an enum value
	53	*/
	54	struct Field {
	55	int32_t prefix; /*< how many characters to remove in the prefix - i.e. UCHAR_ = 5 /
	56	const char str; /< The actual string value /
	57	int32_t num; /*< The numeric value /
	58	};
	59
	60	/**
	61	* Calculate the size of an array.
	62	*/
	63	#define DBG_ARRAY_COUNT(x) (sizeof(x)/sizeof(x[0]))
	64
	65	/**
	66	* Define another field name. Used in an array of Field s
	67	* @param y the common prefix length (i.e. 6 for "USHOE_" )
	68	* @param x the actual enum value - it will be copied in both string and symbolic form.
	69	* @see Field
	70	*/
	71	#define FIELD_NAME_STR(y,x) { y, #x, x }
	72
	73
	74	// TODO: Currently, this whole functionality goes away with UCONFIG_NO_FORMATTING. Should be split up.
	75	#if !UCONFIG_NO_FORMATTING
	76
	77	// Calendar
	78	#include "unicode/ucal.h"
79
80	// 'UCAL_' = 5
81	#define LEN_UCAL 5 /* UCAL_ */
82	static const int32_t count_UCalendarDateFields = UCAL_FIELD_COUNT;
83	static const Field names_UCalendarDateFields[] =
84	{
85	FIELD_NAME_STR( LEN_UCAL, UCAL_ERA ),
86	FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR ),
87	FIELD_NAME_STR( LEN_UCAL, UCAL_MONTH ),
88	FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_YEAR ),
89	FIELD_NAME_STR( LEN_UCAL, UCAL_WEEK_OF_MONTH ),
90	FIELD_NAME_STR( LEN_UCAL, UCAL_DATE ),
91	FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_YEAR ),
92	FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK ),
93	FIELD_NAME_STR( LEN_UCAL, UCAL_DAY_OF_WEEK_IN_MONTH ),
94	FIELD_NAME_STR( LEN_UCAL, UCAL_AM_PM ),
95	FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR ),
96	FIELD_NAME_STR( LEN_UCAL, UCAL_HOUR_OF_DAY ),
97	FIELD_NAME_STR( LEN_UCAL, UCAL_MINUTE ),
98	FIELD_NAME_STR( LEN_UCAL, UCAL_SECOND ),
99	FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECOND ),
100	FIELD_NAME_STR( LEN_UCAL, UCAL_ZONE_OFFSET ),
101	FIELD_NAME_STR( LEN_UCAL, UCAL_DST_OFFSET ),
102	FIELD_NAME_STR( LEN_UCAL, UCAL_YEAR_WOY ),
103	FIELD_NAME_STR( LEN_UCAL, UCAL_DOW_LOCAL ),
104	FIELD_NAME_STR( LEN_UCAL, UCAL_EXTENDED_YEAR ),
105	FIELD_NAME_STR( LEN_UCAL, UCAL_JULIAN_DAY ),
106	FIELD_NAME_STR( LEN_UCAL, UCAL_MILLISECONDS_IN_DAY ),
107	FIELD_NAME_STR( LEN_UCAL, UCAL_IS_LEAP_MONTH ),
108	};
109
110
111	static const int32_t count_UCalendarMonths = UCAL_UNDECIMBER+1;
112	static const Field names_UCalendarMonths[] =
113	{
114	FIELD_NAME_STR( LEN_UCAL, UCAL_JANUARY ),
115	FIELD_NAME_STR( LEN_UCAL, UCAL_FEBRUARY ),
116	FIELD_NAME_STR( LEN_UCAL, UCAL_MARCH ),
117	FIELD_NAME_STR( LEN_UCAL, UCAL_APRIL ),
118	FIELD_NAME_STR( LEN_UCAL, UCAL_MAY ),
119	FIELD_NAME_STR( LEN_UCAL, UCAL_JUNE ),
120	FIELD_NAME_STR( LEN_UCAL, UCAL_JULY ),
121	FIELD_NAME_STR( LEN_UCAL, UCAL_AUGUST ),
122	FIELD_NAME_STR( LEN_UCAL, UCAL_SEPTEMBER ),
123	FIELD_NAME_STR( LEN_UCAL, UCAL_OCTOBER ),
124	FIELD_NAME_STR( LEN_UCAL, UCAL_NOVEMBER ),
125	FIELD_NAME_STR( LEN_UCAL, UCAL_DECEMBER ),
126	FIELD_NAME_STR( LEN_UCAL, UCAL_UNDECIMBER)
127	};
128
129	#include "unicode/udat.h"
130
131	#define LEN_UDAT 5 /* "UDAT_" */
132	static const int32_t count_UDateFormatStyle = UDAT_SHORT+1;
133	static const Field names_UDateFormatStyle[] =
134	{
135	FIELD_NAME_STR( LEN_UDAT, UDAT_FULL ),
136	FIELD_NAME_STR( LEN_UDAT, UDAT_LONG ),
137	FIELD_NAME_STR( LEN_UDAT, UDAT_MEDIUM ),
138	FIELD_NAME_STR( LEN_UDAT, UDAT_SHORT ),
139	/* end regular */
140	/*
141	* negative enums.. leave out for now.
142	FIELD_NAME_STR( LEN_UDAT, UDAT_NONE ),
51004dcb	143	FIELD_NAME_STR( LEN_UDAT, UDAT_PATTERN ),
729e4ab9 A	144	*/
	145	};
	146
	147	#endif
	148
	149	#include "unicode/uloc.h"
	150
	151	#define LEN_UAR 12 /* "ULOC_ACCEPT_" */
	152	static const int32_t count_UAcceptResult = 3;
	153	static const Field names_UAcceptResult[] =
	154	{
	155	FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FAILED ),
	156	FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_VALID ),
	157	FIELD_NAME_STR( LEN_UAR, ULOC_ACCEPT_FALLBACK ),
	158	};
	159
	160	#if !UCONFIG_NO_COLLATION
	161	#include "unicode/ucol.h"
	162	#define LEN_UCOL 5 /* UCOL_ */
	163	static const int32_t count_UColAttributeValue = UCOL_ATTRIBUTE_VALUE_COUNT;
	164	static const Field names_UColAttributeValue[] = {
	165	FIELD_NAME_STR( LEN_UCOL, UCOL_PRIMARY ),
	166	FIELD_NAME_STR( LEN_UCOL, UCOL_SECONDARY ),
	167	FIELD_NAME_STR( LEN_UCOL, UCOL_TERTIARY ),
	168	// FIELD_NAME_STR( LEN_UCOL, UCOL_CE_STRENGTH_LIMIT ),
	169	FIELD_NAME_STR( LEN_UCOL, UCOL_QUATERNARY ),
	170	// gap
	171	FIELD_NAME_STR( LEN_UCOL, UCOL_IDENTICAL ),
	172	// FIELD_NAME_STR( LEN_UCOL, UCOL_STRENGTH_LIMIT ),
	173	FIELD_NAME_STR( LEN_UCOL, UCOL_OFF ),
	174	FIELD_NAME_STR( LEN_UCOL, UCOL_ON ),
	175	// gap
	176	FIELD_NAME_STR( LEN_UCOL, UCOL_SHIFTED ),
	177	FIELD_NAME_STR( LEN_UCOL, UCOL_NON_IGNORABLE ),
	178	// gap
	179	FIELD_NAME_STR( LEN_UCOL, UCOL_LOWER_FIRST ),
	180	FIELD_NAME_STR( LEN_UCOL, UCOL_UPPER_FIRST ),
	181	};
	182
	183	#endif
	184
	185
	186	#include "unicode/icuplug.h"
	187
	188	#define LEN_UPLUG_REASON 13 /* UPLUG_REASON_ */
	189	static const int32_t count_UPlugReason = UPLUG_REASON_COUNT;
	190	static const Field names_UPlugReason[] = {
	191	FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_QUERY ),
	192	FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_LOAD ),
	193	FIELD_NAME_STR( LEN_UPLUG_REASON, UPLUG_REASON_UNLOAD ),
	194	};
	195
	196	#define LEN_UPLUG_LEVEL 12 /* UPLUG_LEVEL_ */
	197	static const int32_t count_UPlugLevel = UPLUG_LEVEL_COUNT;
	198	static const Field names_UPlugLevel[] = {
	199	FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_INVALID ),
	200	FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_UNKNOWN ),
	201	FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_LOW ),
	202	FIELD_NAME_STR( LEN_UPLUG_LEVEL, UPLUG_LEVEL_HIGH ),
	203	};
	204
	205	#define LEN_UDBG 5 /* "UDBG_" */
	206	static const int32_t count_UDebugEnumType = UDBG_ENUM_COUNT;
	207	static const Field names_UDebugEnumType[] =
208	{
209	FIELD_NAME_STR( LEN_UDBG, UDBG_UDebugEnumType ),
210	#if !UCONFIG_NO_FORMATTING
211	FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarDateFields ),
212	FIELD_NAME_STR( LEN_UDBG, UDBG_UCalendarMonths ),
213	FIELD_NAME_STR( LEN_UDBG, UDBG_UDateFormatStyle ),
214	#endif
215	FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugReason ),
216	FIELD_NAME_STR( LEN_UDBG, UDBG_UPlugLevel ),
217	FIELD_NAME_STR( LEN_UDBG, UDBG_UAcceptResult ),
218	#if !UCONFIG_NO_COLLATION
219	FIELD_NAME_STR( LEN_UDBG, UDBG_UColAttributeValue ),
220	#endif
221	};
222
223
224	// --- Add new enum types above this line ---
225
226	#define COUNT_CASE(x) case UDBG_##x: return (actual?count_##x:DBG_ARRAY_COUNT(names_##x));
227	#define COUNT_FAIL_CASE(x) case UDBG_##x: return -1;
228
229	#define FIELD_CASE(x) case UDBG_##x: return names_##x;
230	#define FIELD_FAIL_CASE(x) case UDBG_##x: return NULL;
231
232	// low level
233
234	/**
235	* @param type type of item
236	* @param actual TRUE: for the actual enum's type (UCAL_FIELD_COUNT, etc), or FALSE for the string count
237	*/
238	static int32_t _udbg_enumCount(UDebugEnumType type, UBool actual) {
239	switch(type) {
240	COUNT_CASE(UDebugEnumType)
241	#if !UCONFIG_NO_FORMATTING
242	COUNT_CASE(UCalendarDateFields)
243	COUNT_CASE(UCalendarMonths)
244	COUNT_CASE(UDateFormatStyle)
245	#endif
246	COUNT_CASE(UPlugReason)
247	COUNT_CASE(UPlugLevel)
248	COUNT_CASE(UAcceptResult)
249	#if !UCONFIG_NO_COLLATION
250	COUNT_CASE(UColAttributeValue)
251	#endif
252	// COUNT_FAIL_CASE(UNonExistentEnum)
253	default:
254	return -1;
255	}
256	}
257
258	static const Field* _udbg_enumFields(UDebugEnumType type) {
259	switch(type) {
260	FIELD_CASE(UDebugEnumType)
261	#if !UCONFIG_NO_FORMATTING
262	FIELD_CASE(UCalendarDateFields)
263	FIELD_CASE(UCalendarMonths)
264	FIELD_CASE(UDateFormatStyle)
265	#endif
266	FIELD_CASE(UPlugReason)
267	FIELD_CASE(UPlugLevel)
268	FIELD_CASE(UAcceptResult)
269	// FIELD_FAIL_CASE(UNonExistentEnum)
270	#if !UCONFIG_NO_COLLATION
271	FIELD_CASE(UColAttributeValue)
272	#endif
273	default:
274	return NULL;
275	}
276	}
277
278	// implementation
279
280	int32_t udbg_enumCount(UDebugEnumType type) {
281	return _udbg_enumCount(type, FALSE);
282	}
283
284	int32_t udbg_enumExpectedCount(UDebugEnumType type) {
285	return _udbg_enumCount(type, TRUE);
286	}
287
288	const char * udbg_enumName(UDebugEnumType type, int32_t field) {
289	if(field<0 \|\|
290	field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
291	return NULL;
292	} else {
293	const Field *fields = _udbg_enumFields(type);
294	if(fields == NULL) {
295	return NULL;
296	} else {
297	return fields[field].str + fields[field].prefix;
298	}
299	}
300	}
301
302	int32_t udbg_enumArrayValue(UDebugEnumType type, int32_t field) {
303	if(field<0 \|\|
304	field>=_udbg_enumCount(type,FALSE)) { // also will catch unsupported items
305	return -1;
306	} else {
307	const Field *fields = _udbg_enumFields(type);
308	if(fields == NULL) {
309	return -1;
310	} else {
311	return fields[field].num;
312	}
313	}
314	}
315
316	int32_t udbg_enumByName(UDebugEnumType type, const char *value) {
317	if(type<0\|\|type>=_udbg_enumCount(UDBG_UDebugEnumType, TRUE)) {
318	return -1; // type out of range
319	}
320	const Field *fields = _udbg_enumFields(type);
321	for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
322	if(!strcmp(value, fields[field].str + fields[field].prefix)) {
323	return fields[field].num;
324	}
325	}
326	// try with the prefix
327	for(int32_t field = 0;field<_udbg_enumCount(type, FALSE);field++) {
328	if(!strcmp(value, fields[field].str)) {
329	return fields[field].num;
330	}
331	}
332	// fail
333	return -1;
334	}
4388f060 A	335
	336	/* platform info */
	337	/**
	338	* Print the current platform
	339	*/
	340	U_CAPI const char *udbg_getPlatform(void)
	341	{
	342	#if U_PLATFORM_HAS_WIN32_API
	343	return "Windows";
	344	#elif U_PLATFORM == U_PF_UNKNOWN
	345	return "unknown";
51004dcb A	346	#elif U_PLATFORM == U_PF_DARWIN
	347	return "Darwin";
	348	#elif U_PLATFORM == U_PF_QNX
	349	return "QNX";
	350	#elif U_PLATFORM == U_PF_LINUX
	351	return "Linux";
	352	#elif U_PLATFORM == U_PF_ANDROID
	353	return "Android";
	354	#elif U_PLATFORM == U_PF_CLASSIC_MACOS
	355	return "MacOS (Classic)";
	356	#elif U_PLATFORM == U_PF_OS390
	357	return "IBM z";
	358	#elif U_PLATFORM == U_PF_OS400
	359	return "IBM i";
4388f060 A	360	#else
	361	return "Other (POSIX-like)";
	362	#endif
	363	}
	364
	365	struct USystemParams;
	366
	367	typedef int32_t U_CALLCONV USystemParameterCallback(const USystemParams param, char target, int32_t targetCapacity, UErrorCode *status);
	368
	369	struct USystemParams {
	370	const char *paramName;
	371	USystemParameterCallback *paramFunction;
	372	const char *paramStr;
	373	int32_t paramInt;
	374	};
	375
	376	/* parameter types */
	377	U_CAPI int32_t
	378	paramEmpty(const USystemParams * /* param /, char target, int32_t targetCapacity, UErrorCode *status) {
	379	if(U_FAILURE(*status))return 0;
	380	return u_terminateChars(target, targetCapacity, 0, status);
	381	}
	382
	383	U_CAPI int32_t
	384	paramStatic(const USystemParams param, char target, int32_t targetCapacity, UErrorCode *status) {
	385	if(param->paramStr==NULL) return paramEmpty(param,target,targetCapacity,status);
	386	if(U_FAILURE(*status))return 0;
	387	int32_t len = uprv_strlen(param->paramStr);
	388	if(target!=NULL) {
	389	uprv_strncpy(target,param->paramStr,uprv_min(len,targetCapacity));
	390	}
	391	return u_terminateChars(target, targetCapacity, len, status);
	392	}
	393
51004dcb A	394	static const char *nullString = "(null)";
51004dcb A	395
4388f060	396	static int32_t stringToStringBuffer(char target, int32_t targetCapacity, const char str, UErrorCode *status) {
51004dcb A	397	if(str==NULL) str=nullString;
51004dcb A	398
4388f060	399	int32_t len = uprv_strlen(str);
51004dcb A	400	if (U_SUCCESS(*status)) {
	401	if(target!=NULL) {
	402	uprv_strncpy(target,str,uprv_min(len,targetCapacity));
	403	}
	404	} else {
	405	const char s = u_errorName(status);
	406	len = uprv_strlen(s);
	407	if(target!=NULL) {
	408	uprv_strncpy(target,s,uprv_min(len,targetCapacity));
	409	}
4388f060 A	410	}
	411	return u_terminateChars(target, targetCapacity, len, status);
	412	}
	413
	414	static int32_t integerToStringBuffer(char target, int32_t targetCapacity, int32_t n, int32_t radix, UErrorCode status) {
	415	if(U_FAILURE(*status)) return 0;
	416	char str[300];
	417	T_CString_integerToString(str,n,radix);
	418	return stringToStringBuffer(target,targetCapacity,str,status);
	419	}
	420
	421	U_CAPI int32_t
	422	paramInteger(const USystemParams param, char target, int32_t targetCapacity, UErrorCode *status) {
	423	if(U_FAILURE(*status))return 0;
	424	if(param->paramStr==NULL \|\| param->paramStr[0]=='d') {
	425	return integerToStringBuffer(target,targetCapacity,param->paramInt, 10,status);
	426	} else if(param->paramStr[0]=='x') {
	427	return integerToStringBuffer(target,targetCapacity,param->paramInt, 16,status);
	428	} else if(param->paramStr[0]=='o') {
	429	return integerToStringBuffer(target,targetCapacity,param->paramInt, 8,status);
	430	} else if(param->paramStr[0]=='b') {
	431	return integerToStringBuffer(target,targetCapacity,param->paramInt, 2,status);
	432	} else {
	433	*status = U_INTERNAL_PROGRAM_ERROR;
	434	return 0;
	435	}
	436	}
	437
	438
	439	U_CAPI int32_t
	440	paramCldrVersion(const USystemParams * /* param /, char target, int32_t targetCapacity, UErrorCode *status) {
	441	if(U_FAILURE(*status))return 0;
	442	char str[200]="";
	443	UVersionInfo icu;
	444
	445	ulocdata_getCLDRVersion(icu, status);
	446	if(U_SUCCESS(*status)) {
	447	u_versionToString(icu, str);
	448	return stringToStringBuffer(target,targetCapacity,str,status);
	449	} else {
	450	return 0;
	451	}
	452	}
	453
	454
	455	#if !UCONFIG_NO_FORMATTING
	456	U_CAPI int32_t
	457	paramTimezoneDefault(const USystemParams * /* param /, char target, int32_t targetCapacity, UErrorCode *status) {
	458	if(U_FAILURE(*status))return 0;
	459	UChar buf[100];
	460	char buf2[100];
	461	int32_t len;
	462
	463	len = ucal_getDefaultTimeZone(buf, 100, status);
	464	if(U_SUCCESS(*status)&&len>0) {
	465	u_UCharsToChars(buf, buf2, len+1);
	466	return stringToStringBuffer(target,targetCapacity, buf2,status);
	467	} else {
	468	return 0;
	469	}
	470	}
	471	#endif
	472
	473	U_CAPI int32_t
474	paramLocaleDefaultBcp47(const USystemParams * /* param /, char target, int32_t targetCapacity, UErrorCode *status) {
475	if(U_FAILURE(*status))return 0;
476	const char *def = uloc_getDefault();
477	return uloc_toLanguageTag(def,target,targetCapacity,FALSE,status);
478	}
479
480
481	/* simple 1-liner param functions */
482	#define STRING_PARAM(func, str) U_CAPI int32_t \
483	func(const USystemParams , char target, int32_t targetCapacity, UErrorCode *status) \
484	{ return stringToStringBuffer(target,targetCapacity,(str),status); }
485
486	STRING_PARAM(paramIcudataPath, u_getDataDirectory())
487	STRING_PARAM(paramPlatform, udbg_getPlatform())
488	STRING_PARAM(paramLocaleDefault, uloc_getDefault())
489	#if !UCONFIG_NO_CONVERSION
490	STRING_PARAM(paramConverterDefault, ucnv_getDefaultName())
491	#endif
492
493	#if !UCONFIG_NO_FORMATTING
494	STRING_PARAM(paramTimezoneVersion, ucal_getTZDataVersion(status))
495	#endif
496
51004dcb	497	static const USystemParams systemParams[] = {
4388f060 A	498	{ "copyright", paramStatic, U_COPYRIGHT_STRING,0 },
	499	{ "product", paramStatic, "icu4c",0 },
	500	{ "product.full", paramStatic, "International Components for Unicode for C/C++",0 },
	501	{ "version", paramStatic, U_ICU_VERSION,0 },
	502	{ "version.unicode", paramStatic, U_UNICODE_VERSION,0 },
	503	{ "platform.number", paramInteger, "d",U_PLATFORM},
	504	{ "platform.type", paramPlatform, NULL ,0},
	505	{ "locale.default", paramLocaleDefault, NULL, 0},
	506	{ "locale.default.bcp47", paramLocaleDefaultBcp47, NULL, 0},
	507	#if !UCONFIG_NO_CONVERSION
	508	{ "converter.default", paramConverterDefault, NULL, 0},
	509	#endif
	510	{ "icudata.name", paramStatic, U_ICUDATA_NAME, 0},
	511	{ "icudata.path", paramIcudataPath, NULL, 0},
	512
	513	{ "cldr.version", paramCldrVersion, NULL, 0},
	514
	515	#if !UCONFIG_NO_FORMATTING
	516	{ "tz.version", paramTimezoneVersion, NULL, 0},
	517	{ "tz.default", paramTimezoneDefault, NULL, 0},
	518	#endif
	519
	520	{ "cpu.bits", paramInteger, "d", (sizeof(void))8},
	521	{ "cpu.big_endian", paramInteger, "b", U_IS_BIG_ENDIAN},
	522	{ "os.wchar_width", paramInteger, "d", U_SIZEOF_WCHAR_T},
	523	{ "os.charset_family", paramInteger, "d", U_CHARSET_FAMILY},
	524	#if defined (U_HOST)
	525	{ "os.host", paramStatic, U_HOST, 0},
	526	#endif
	527	#if defined (U_BUILD)
	528	{ "build.build", paramStatic, U_BUILD, 0},
	529	#endif
	530	#if defined (U_CC)
	531	{ "build.cc", paramStatic, U_CC, 0},
	532	#endif
	533	#if defined (U_CXX)
	534	{ "build.cxx", paramStatic, U_CXX, 0},
	535	#endif
	536	#if defined (CYGWINMSVC)
	537	{ "build.cygwinmsvc", paramInteger, "b", 1},
	538	#endif
51004dcb A	539	{ "uconfig.internal_digitlist", paramInteger, "b", 1}, /* always 1 */
	540	{ "uconfig.have_parseallinput", paramInteger, "b", UCONFIG_HAVE_PARSEALLINPUT},
	541	{ "uconfig.format_fastpaths_49",paramInteger, "b", UCONFIG_FORMAT_FASTPATHS_49},
4388f060 A	542
	543
	544	};
	545
	546	#define U_SYSPARAM_COUNT (sizeof(systemParams)/sizeof(systemParams[0]))
	547
	548	U_CAPI const char *udbg_getSystemParameterNameByIndex(int32_t i) {
	549	if(i>=0 && i < (int32_t)U_SYSPARAM_COUNT) {
	550	return systemParams[i].paramName;
	551	} else {
	552	return NULL;
	553	}
	554	}
	555
	556
	557	U_CAPI int32_t udbg_getSystemParameterValueByIndex(int32_t i, char buffer, int32_t bufferCapacity, UErrorCode status) {
	558	if(i>=0 && i< (int32_t)U_SYSPARAM_COUNT) {
	559	return systemParams[i].paramFunction(&(systemParams[i]),buffer,bufferCapacity,status);
	560	} else {
	561	return 0;
	562	}
	563	}
	564
	565	U_CAPI void udbg_writeIcuInfo(FILE *out) {
	566	char str[2000];
	567	/* todo: API for writing DTD? */
	568	fprintf(out, " <icuSystemParams type=\"icu4c\">\n");
	569	const char *paramName;
	570	for(int32_t i=0;(paramName=udbg_getSystemParameterNameByIndex(i))!=NULL;i++) {
	571	UErrorCode status2 = U_ZERO_ERROR;
	572	udbg_getSystemParameterValueByIndex(i, str,2000,&status2);
	573	if(U_SUCCESS(status2)) {
	574	fprintf(out," <param name=\"%s\">%s</param>\n", paramName,str);
	575	} else {
	576	fprintf(out," <!-- n=\"%s\" ERROR: %s -->\n", paramName, u_errorName(status2));
	577	}
	578	}
	579	fprintf(out, " </icuSystemParams>\n");
	580	}