/*
**********************************************************************
*   Copyright (C) 1997-2001, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
*
* File ULOC.CPP
*
* Modification History:
*
*   Date        Name        Description
*   04/01/97    aliu        Creation.
*   08/21/98    stephen     JDK 1.2 sync
*   12/08/98    rtg         New Locale implementation and C API
*   03/15/99    damiba      overhaul.
*   04/06/99    stephen     changed setDefault() to realloc and copy
*   06/14/99    stephen     Changed calls to ures_open for new params
*   07/21/99    stephen     Modified setDefault() to propagate to C++
*****************************************************************************/

/*
   POSIX's locale format, from putil.c: [no spaces]

     ll [ _CC ] [ . MM ] [ @ VV]

     l = lang, C = ctry, M = charmap, V = variant
*/


#include "unicode/uloc.h"
#include "unicode/locid.h"

#include "unicode/utypes.h"
#include "uresimp.h"
#include "unicode/uchar.h"
#include "umutex.h"
#include "cstring.h"
#include "unicode/ustring.h"
#include "cmemory.h"

/****************************************************************************
  Global variable and type definitions
*****************************************************************************/

/* UnicodeString stuff */
typedef struct UnicodeString UnicodeString;

U_CFUNC int32_t T_UnicodeString_length(const UnicodeString *s);

U_CAPI int32_t
T_UnicodeString_extract(const UnicodeString *s, char *dst);

/* Locale stuff from locid.cpp */
U_CAPI void locale_set_default(const char *id);

/* These strings describe the resources we attempt to load from
 the locale ResourceBundle data file.*/
static const char* _kLocaleID       = "LocaleID";
static const char* _kLanguages      = "Languages";
static const char* _kCountries      = "Countries";

#if 0
/* We don't use these resources currently */
static const char* _kLocaleString   = "LocaleString";
static const char* _kShortLanguage  = "ShortLanguage";
static const char* _kShortCountry   = "ShortCountry";
#endif

#define TEMPBUFSIZE 8

/*Some static strings needed in the getDisplay* functions*/
static const UChar openParen[] = { (UChar)0x0020 /* space */, (UChar)0x0028 /* ( */, (UChar)0x0000};
static const UChar comma[] = { (UChar)0x002C /* , */, (UChar)0x0020 /* space */, (UChar)0x0000};
static const UChar closeParen[] = { (UChar)0x0029 /* ) */, (UChar)0x0000};


static char _defaultLocale[ULOC_FULLNAME_CAPACITY] = "en_US";
static UBool _emptyDefaultLocale = TRUE;

static char** _installedLocales = NULL;
static int32_t _installedLocalesCount = 0;


static const char _languages[] =
"aa\0ab\0af\0am\0ar\0as\0ay\0az\0"
"ba\0be\0bg\0bh\0bi\0bn\0bo\0br\0"
"ca\0co\0cs\0cy\0da\0de\0dz\0"
"el\0en\0eo\0es\0et\0eu\0fa\0fi\0fj\0fo\0fr\0fy\0"
"ga\0gd\0gl\0gn\0gu\0ha\0he\0hi\0hr\0hu\0hy\0"
"ia\0id\0ie\0ik\0in\0is\0it\0iu\0iw\0"
"ja\0ji\0jw\0ka\0kk\0kl\0km\0kn\0ko\0ks\0ku\0ky\0"
"la\0ln\0lo\0lt\0lv\0"
"mg\0mi\0mk\0ml\0mn\0mo\0mr\0ms\0mt\0my\0"
"na\0ne\0nl\0no\0oc\0om\0or\0"
"pa\0pl\0ps\0pt\0qu\0rm\0rn\0ro\0ru\0rw\0"
"sa\0sd\0sg\0sh\0si\0sk\0sl\0sm\0sn\0so\0sq\0sr\0ss\0st\0su\0sv\0sw\0"
"ta\0te\0tg\0th\0ti\0tk\0tl\0tn\0to\0tr\0ts\0tt\0tw\0"
"ug\0uk\0ur\0uz\0vi\0vo\0wo\0xh\0yi\0yo\0za\0zh\0zu";
/* This list MUST be in sorted order, and MUST contain only two-letter codes! */

static const char _languages3[] =
"aar\0abk\0afr\0amh\0ara\0asm\0aym\0aze\0"
"bak\0bel\0bul\0bih\0bis\0ben\0bod\0bre\0"
"cat\0cos\0ces\0cym\0dan\0deu\0dzo\0"
"ell\0eng\0epo\0spa\0est\0eus\0fas\0fin\0fij\0fao\0fra\0fry\0"
"gai\0gdh\0glg\0grn\0guj\0hau\0heb\0hin\0hrv\0hun\0hye\0"
"ina\0ind\0ile\0ipk\0ind\0isl\0ita\0iku\0heb\0"
"jpn\0yid\0jaw\0kat\0kaz\0kal\0khm\0kan\0kor\0kas\0kur\0kir\0"
"lat\0lin\0lao\0lit\0lav\0"
    "mlg\0mri\0mkd\0mal\0mon\0mol\0mar\0msa\0mlt\0mya\0"
"nau\0nep\0nld\0nor\0oci\0orm\0ori\0"
"pan\0pol\0pus\0por\0que\0roh\0run\0ron\0rus\0kin\0"
"san\0snd\0sag\0srp\0sin\0slk\0slv\0smo\0sna\0som\0sqi\0srp\0ssw\0sot\0sun\0swe\0swa\0"
"tat\0tel\0tgk\0tha\0tir\0tuk\0tgl\0tsn\0ton\0tur\0tsn\0tat\0twi\0"
"uig\0ukr\0urd\0uzb\0vie\0vol\0wol\0xho\0yid\0yor\0zha\0zho\0zul";
/* This list MUST contain a three-letter code for every two-letter code in the
   list above, and they MUST ne in the same order (i.e., the same language must
   be in the same place in both lists)! */

static const char _countries[] =
"AD\0AE\0AF\0AG\0AI\0AL\0AM\0AN\0AO\0AQ\0AR\0AS\0AT\0AU\0AW\0AZ\0"
"BA\0BB\0BD\0BE\0BF\0BG\0BH\0BI\0BJ\0BM\0BN\0BO\0BR\0BS\0BT\0BV\0BW\0BY\0BZ\0"
"CA\0CC\0CF\0CG\0CH\0CI\0CK\0CL\0CM\0CN\0CO\0CR\0CU\0CV\0CX\0CY\0CZ\0"
"DE\0DJ\0DK\0DM\0DO\0DZ\0EC\0EE\0EG\0EH\0ER\0ES\0ET\0"
"FI\0FJ\0FK\0FM\0FO\0FR\0FX\0"
"GA\0GB\0GD\0GE\0GF\0GH\0GI\0GL\0GM\0GN\0GP\0GQ\0GR\0GS\0GT\0GU\0GW\0GY\0"
"HK\0HM\0HN\0HR\0HT\0HU\0ID\0IE\0IL\0IN\0IO\0IQ\0IR\0IS\0IT\0"
"JM\0JO\0JP\0KE\0KG\0KH\0KI\0KM\0KN\0KP\0KR\0KW\0KY\0KZ\0"
"LA\0LB\0LC\0LI\0LK\0LR\0LS\0LT\0LU\0LV\0LY\0"
"MA\0MC\0MD\0MG\0MH\0MK\0ML\0MM\0MN\0MO\0MP\0MQ\0MR\0MS\0MT\0MU\0MV\0MW\0MX\0MY\0MZ\0"
"NA\0NC\0NE\0NF\0NG\0NI\0NL\0NO\0NP\0NR\0NU\0NZ\0OM\0"
"PA\0PE\0PF\0PG\0PH\0PK\0PL\0PM\0PN\0PR\0PT\0PW\0PY\0QA\0RE\0RO\0RU\0RW\0"
"SA\0SB\0SC\0SD\0SE\0SG\0SH\0SI\0SJ\0SK\0SL\0SM\0SN\0SO\0SR\0ST\0SV\0SY\0SZ\0"
"TC\0TD\0TF\0TG\0TH\0TJ\0TK\0TM\0TN\0TO\0TP\0TR\0TT\0TV\0TW\0TZ\0"
"UA\0UG\0UM\0US\0UY\0UZ\0VA\0VC\0VE\0VG\0VI\0VN\0VU\0"
"WF\0WS\0YE\0YT\0YU\0ZA\0ZM\0ZR\0ZW";
/* This list MUST be in sorted order, and MUST contain only two-letter codes! */

static const char _countries3[] =
"AND\0ARE\0AFG\0ATG\0AIA\0ALB\0ARM\0ANT\0AGO\0ATA\0ARG\0ASM\0AUT\0AUS\0ABW\0AZE\0"
"BIH\0BRB\0BGD\0BEL\0BFA\0BGR\0BHR\0BDI\0BEN\0BMU\0BRN\0BOL\0BRA\0BHS\0BTN\0BVT\0BWA"
"\0BLR\0BLZ\0"
"CAN\0CCK\0CAF\0COG\0CHE\0CIV\0COK\0CHL\0CMR\0CHN\0COL\0CRI\0CUB\0CPV\0CXR\0CYP\0CZE\0"
"DEU\0DJI\0DNK\0DMA\0DOM\0DZA\0ECU\0EST\0EGY\0ESH\0ERI\0ESP\0ETH\0"
"FIN\0FJI\0FLK\0FSM\0FRO\0FRA\0FXX\0"
"GAB\0GBR\0GRD\0GEO\0GUF\0GHA\0GIB\0GRL\0GMB\0GIN\0GLP\0GNQ\0GRC\0SGS\0GTM\0GUM"
"\0GNB\0GUY\0"
"HKG\0HMD\0HND\0HRV\0HTI\0HUN\0IDN\0IRL\0ISR\0IND\0IOT\0IRQ\0IRN\0ISL\0ITA\0"
"JAM\0JOR\0JPN\0KEN\0KGZ\0KHM\0KIR\0COM\0KNA\0PRK\0KOR\0KWT\0CYM\0KAZ\0"
"LAO\0LBN\0LCA\0LIE\0LKA\0LBR\0LSO\0LTU\0LUX\0LVA\0LBY\0"
"MAR\0MCO\0MDA\0MDG\0MHL\0MKD\0MLI\0MMR\0MNG\0MAC\0MNP\0MTQ\0MRT\0MSR\0MLT\0MUS\0"
"MDV\0MWI\0MEX\0MYS\0MOZ\0"
"NAM\0NCL\0NER\0NFK\0NGA\0NIC\0NLD\0NOR\0NPL\0NRU\0NIU\0NZL\0OMN\0"
"PAN\0PER\0PYF\0PNG\0PHL\0PAK\0POL\0SPM\0PCN\0PRI\0PRT\0PLW\0PRY\0QAT\0REU\0ROM"
"\0RUS\0RWA\0"
"SAU\0SLB\0SYC\0SDN\0SWE\0SGP\0SHN\0SVN\0SJM\0SVK\0SLE\0SMR\0SEN\0SOM\0SUR\0STP"
"\0SLV\0SYR\0SWZ\0"
"TCA\0TCD\0ATF\0TGO\0THA\0TJK\0TKL\0TKM\0TUN\0TON\0TMP\0TUR\0TTO\0TUV\0TWN\0TZA\0"
"UKR\0UGA\0UMI\0USA\0URY\0UZB\0VAT\0VCT\0VEN\0VGB\0VIR\0VNM\0VUT\0"
"WLF\0WSM\0YEM\0MYT\0YUG\0ZAF\0ZMB\0ZAR\0ZWE";
/* This list MUST contain a three-letter code for every two-letter code in
   the above list, and they MUST be listed in the same order! */

static char** _isoLanguages = NULL;
static char** _isoCountries = NULL;

/*******************************************************************************
  Implementation function definitions
*******************************************************************************/

static int16_t _findIndex(const char* list, int32_t listLength, const char* key);

/*Works like strchr with '_' pr '-'*/
static const char* _findCharSeparator(const char* string);

/*Lazy evaluated the list of installed locales*/
static void _lazyEvaluate_installedLocales(void);

/*returns TRUE if a is an ID separator FALSE otherwise*/
#define _isIDSeparator(a) (a == '_' || a == '-')

#define _isPrefixLetter(a) ((a=='x')||(a=='X')||(a=='i')||(a=='I'))
/*returns TRUE if one of the special prefixes is here (s=string)
  'x-' or 'i-' */
#define _isIDPrefix(s) (_isPrefixLetter(s[0])&&_isIDSeparator(s[1]))

/* Dot terminates it because of POSIX form  where dot precedes the codepage
 * except for variant
 */
#define _isTerminator(a)  ((a==0)||(a=='.')||(a=='@'))


/*******************************************************************************
  API function definitions
*******************************************************************************/


static const char* _findCharSeparator(const char* string)
{
    if (string == NULL)
        return NULL;
    /*Keeps iterating until an ID separator is found*/
    while (*string && !_isIDSeparator(*string))
        string++;
    if (*string)
        return string;
    else
        return NULL;
}


static int16_t _findIndex(const char* list, int32_t listLength, const char* key)
{
    const char* anchor = list;
    const char* listEnd = anchor + listLength;
    UBool found = FALSE;
    int tokenSize = uprv_strlen(list)+1; /*gets the size of the tokens*/
    
    while (!found && list<listEnd)
    {
        if (uprv_strcmp(key, list) == 0) 
        {
            found = TRUE;
            break;
        }
        list += tokenSize;
    }
    if (found == TRUE)
        return (int16_t)((list - anchor)/tokenSize);
    else
        return -1;
}

const char* uloc_getDefault()
{
    UErrorCode err = U_ZERO_ERROR;
    
    /*lazy evaluates _defaultLocale*/
    if (_emptyDefaultLocale) 
    {
        uloc_setDefault(NULL, &err);
    }
    
    return _defaultLocale;
}

void uloc_setDefault(const char*   newDefaultLocale,
             UErrorCode* err) 
{
    if (U_FAILURE(*err))
        return;
    /* the error code isn't currently used for anything by this function*/
    
    if (newDefaultLocale == NULL) 
    {
        newDefaultLocale = uprv_getDefaultLocaleID();
    }
    
    umtx_lock(NULL);
    uprv_strncpy(_defaultLocale, newDefaultLocale, ULOC_FULLNAME_CAPACITY - 1);
    _defaultLocale[ULOC_FULLNAME_CAPACITY - 1] = 0;
    _emptyDefaultLocale = FALSE;
    umtx_unlock(NULL);
    
    /* propagate change to C++ */
    locale_set_default(newDefaultLocale);
}


int32_t uloc_getParent(const char*    localeID,
               char* parent,
               int32_t parentCapacity,
               UErrorCode* err)
{
    int i=0;
    int offset = 0;
    int count = 0;
    
    if (U_FAILURE(*err))
        return 0;
    
    if (localeID == NULL)
        localeID = uloc_getDefault();
    
    
    while (localeID[offset]&&(count < 2))
    {
        if (_isIDSeparator(localeID[offset++]))
            count++;
    }
    
    /*finds the second IDSeparator*/
    while (offset && !_isIDSeparator(localeID[offset]))
    {
        offset--;
    }
    
    
    /*Loop updates i to the size of the parent
    but only copies into the buffer as much as the buffer can bare*/
    while (i < offset)
    {
        if (parentCapacity > i)
            parent[i] = localeID[i];
        i++;
    }
    
    /*Sets the error code on case of need*/
    if (i >= parentCapacity )
    {
        *err = U_BUFFER_OVERFLOW_ERROR;
    }
    
    if (parentCapacity>0)
        parent[uprv_min(i,parentCapacity-1)] = '\0';
    
    return i+1;
}

int32_t
uloc_getLanguage(const char*    localeID,
         char* language,
         int32_t languageCapacity,
         UErrorCode* err)
{
    int i=0;
    
    
    if (U_FAILURE(*err))
        return 0;
    
    if (localeID == NULL)
        localeID = uloc_getDefault();
    
    /* If it starts with i- or x- */
    if(_isIDPrefix(localeID))
    {
        if(languageCapacity > i)
        {
            language[i] = (char)uprv_tolower(*localeID);
        }
        i++;
        localeID++;
        
        if(languageCapacity > i)
        {
            language[i] = '-';
        }
        i++;
        localeID++;
    }
    
    /*Loop updates i to the size of the language
    but only copies into the buffer as much as the buffer can bare*/
    while (!_isTerminator(*localeID) && !_isIDSeparator(*localeID))
    {
        if (languageCapacity > i)
            language[i] = (char)uprv_tolower(*localeID);
        i++;
        localeID++;
    }
    
    if (i >= languageCapacity )
    {
        *err = U_BUFFER_OVERFLOW_ERROR;
    }
    
    if (languageCapacity > 0) 
    {
        language[uprv_min(i,languageCapacity-1)] = '\0';
    }
    
    return i+1;
}


int32_t uloc_getCountry(const char* localeID,
            char* country,
            int32_t countryCapacity,
            UErrorCode* err) 
{
    int i=0;
    
    if (U_FAILURE(*err))
        return 0;
    if (localeID == NULL)
        localeID = uloc_getDefault();
    
    
    /* skip over i- or x- */
    if(_isIDPrefix(localeID))
    {
        localeID += 2;
    }
    
    localeID = _findCharSeparator(localeID);
    
    /*Loop updates i to the size of the language
    but only copies into the buffer as much as the buffer can bare*/
    if (localeID)
    {
        ++localeID;
        while (!_isTerminator(*localeID) && !_isIDSeparator(*localeID))
        {
            if (countryCapacity > i)
                country[i] = (char)uprv_toupper(*localeID);
            i++;
            localeID++;
        }
    }
    
    if (i >= countryCapacity )
    {
        *err = U_BUFFER_OVERFLOW_ERROR;
    }
    
    if (countryCapacity > 0) {
        country[uprv_min(i,countryCapacity-1)] = '\0';
    }
    return i+1;
}

int32_t uloc_getVariant(const char* localeID,
                        char* variant,
                        int32_t variantCapacity,
                        UErrorCode* err) 
{
    int i=0;
    const char *p = localeID;
    
    if (U_FAILURE(*err))
        return 0;
    if (localeID == NULL)
    {
        localeID = uloc_getDefault();
    }
    
    /* skip over i- or x- */
    if(_isIDPrefix(localeID))
    {
        localeID += 2;
    }
    
    localeID = _findCharSeparator(localeID);
    if (localeID)
    {
        localeID = _findCharSeparator(++localeID);
    }
    
    if (localeID)
    {
        ++localeID;
        /*Loop updates i to the size of the language
        but only copies into the buffer as much as the buffer can bear*/
        while (!_isTerminator(*localeID))
        {
            if (variantCapacity > i)
                variant[i] = (char)uprv_toupper(*localeID);
            i++;
            localeID++;
        }
    }
    
    /* But wait, there's more! 
    **IFF** no variant was otherwise found, take one from @...
    */
    if ( (i == 0) &&  /* Found nothing (zero chars copied) */
        (localeID = uprv_strrchr(p, '@')) != NULL)
    {
        localeID++; /* point after the @ */
                    /* Note that we will stop at a period if the user accidentally
                       put a period after the @ sign */

        /* repeat above copying loop */
        while (!_isTerminator(*localeID))
        {
            if (variantCapacity > i)
                variant[i] = (char)uprv_toupper(*localeID);
            i++;
            localeID++;
        }
    }

    if (i >= variantCapacity )
    {
        *err = U_BUFFER_OVERFLOW_ERROR;
    }

    if (variantCapacity>0) {
        variant[uprv_min(i,variantCapacity-1)] = '\0';
    }
    return i+1;
}

int32_t uloc_getName(const char* localeID,
             char* name,
             int32_t nameCapacity,
             UErrorCode* err)  
{
    int i= 0;       /* total required size */
    int n= 0;       /* How much has been copied currently */
    int varSze = 0; /* How big the variant is */
    int cntSze = 0; /* How big the country is */
    
    UErrorCode int_err = U_ZERO_ERROR;
    
    if (U_FAILURE(*err)) return 0;
    
    /*First we preflight the components in order to ensure a valid return value*/
    if (localeID == NULL)    localeID = uloc_getDefault();
    
    cntSze = uloc_getCountry(localeID, 
        NULL , 
        0,
        &int_err);
    int_err = U_ZERO_ERROR;
    varSze = uloc_getVariant(localeID, 
        NULL , 
        0,
        &int_err);
    
    int_err = U_ZERO_ERROR;
    i = uloc_getLanguage(localeID, 
        NULL,
        0, 
        &int_err);
    
    /*Adjust for the zero terminators*/
    --varSze;
    --cntSze;
    /* i is still languagesize+1 for the terminator */
    
    /* Add space for underscores */
    if (varSze)
    {
        i+= 2;  /* if theres a variant, it will ALWAYS contain two underscores. */
    }
    else
    {
        if (cntSze)
        {
            i++; /* Otherwise - only language _ country. */
        }
    }
    
    /* Update i (total req'd size) */
    i += cntSze + varSze;
    
    if(nameCapacity)  /* If size is zero, skip the actual copy */
    {
        /* Now, the real copying */
        int_err = U_ZERO_ERROR;
        
        uloc_getLanguage(localeID, 
            name,
            nameCapacity /* -(n=0) */,  
            &int_err);
        
        n += uprv_strlen(name);
        
        /*We fill in the users buffer*/
        if ((n<nameCapacity) && cntSze)
        {
            if(U_SUCCESS(int_err))
            {
                name[n++] = '_';
            }
            
            uloc_getCountry(localeID,
                name + n,
                nameCapacity - n,
                &int_err);
            n += cntSze;
            
            if (varSze && (n<nameCapacity))
            {
                if(U_SUCCESS(int_err))
                {
                    name[n++] = '_';
                }
                
                uloc_getVariant(localeID,
                    name + n,
                    nameCapacity - n,
                    &int_err);
            }
            
        }
        else if((n<nameCapacity) && varSze)
        {
            if (U_SUCCESS(int_err))
            {
                name[n++] = '_';
                if(n<nameCapacity)
                    name[n++] = '_';
            }
            
            uloc_getVariant(localeID,
                name + n,
                nameCapacity - n,
                &int_err);
        }
        
        /* Tie it off */
        name[uprv_min(i,nameCapacity-1)] = '\0';
    }   /* end (if nameCapacity > 0) */
    
    *err  = int_err;
    
    return i;
}
       
const char* uloc_getISO3Language(const char* localeID) 
{
  int16_t offset;
  char lang[TEMPBUFSIZE];
  UErrorCode err = U_ZERO_ERROR;

  if (localeID == NULL)
  {
      localeID = uloc_getDefault();
  }
  uloc_getLanguage(localeID, lang, TEMPBUFSIZE, &err);
  if (U_FAILURE(err))
      return "";
  offset = _findIndex(_languages, sizeof(_languages),lang);
  if (offset < 0)
      return "";
  return &(_languages3[offset * 4]);
}

const char* uloc_getISO3Country(const char* localeID) 
{
    int16_t offset;
    char cntry[TEMPBUFSIZE];
    UErrorCode err = U_ZERO_ERROR;
    
    if (localeID == NULL)
    {
        localeID = uloc_getDefault();
    }
    uloc_getCountry(localeID, cntry, TEMPBUFSIZE, &err);
    if (U_FAILURE(err))
        return "";
    offset = _findIndex(_countries, sizeof(_countries), cntry);
    if (offset < 0)
        return "";
    
    return &(_countries3[offset * 4]);
}

uint32_t uloc_getLCID(const char* localeID) 
{
    UErrorCode err = U_ZERO_ERROR;
    char temp[30];
    const UChar* lcid = NULL;
    int32_t lcidLen = 0;
    uint32_t result = 0;
    UResourceBundle* bundle = ures_open(NULL, localeID, &err);
    
    if (U_SUCCESS(err))
    {
        lcid = ures_getStringByKey(bundle, _kLocaleID, &lcidLen, &err);
        ures_close(bundle);
        if (U_FAILURE(err) || !lcid || lcidLen == 0)
        {
            return 0;
        }
        u_austrcpy(temp, lcid);
        result = (uint32_t)T_CString_stringToInteger(temp, 16);
    }
    
    return result;
}

int32_t uloc_getDisplayLanguage(const char* locale,
                const char* inLocale,
                UChar* language,
                int32_t languageCapacity,
                UErrorCode* status) 
{
    const UChar* result = NULL;
    int32_t resultLen = 0;
    int langBufSize;
    char inLanguageBuffer[TEMPBUFSIZE];
    char inLocaleBuffer[TEMPBUFSIZE];
    UErrorCode err = U_ZERO_ERROR;
    UResourceBundle* bundle;
    UBool isDefaultLocale = FALSE;
    UBool done = FALSE;
    
    if (U_FAILURE(*status))
        return 0;
    
    if (inLocale == NULL) 
    {
        inLocale = uloc_getDefault();
        isDefaultLocale = TRUE;
    }
    else if (uprv_strcmp(inLocale, uloc_getDefault()) == 0)
    {
        isDefaultLocale = TRUE;
    }
    /*truncates the fallback mechanism if we start out with a defaultLocale*/
    
    if (locale == NULL)
        locale = uloc_getDefault();
    
    /*extracts the language*/
    langBufSize = uloc_getLanguage(locale,
        inLanguageBuffer,
        TEMPBUFSIZE,
        &err);  
    
    
    /*We need to implement a fallback mechanism here because we are getting keys out of a
    tagged array, there is no capability of doing this with fallback through the resource
    bundle API*/
    
    if (langBufSize > 1)
    {
        do 
        {    
            /*
            If we are at the root locale ("")
            The first time we fall back to the full default locale
            As we iterate down the latter, if we hit the root locale ("")
            we pass it to the resource bundle api so it checks default.txt
            */
            
            if (inLocale[0] == '\0')
            {
                if (!isDefaultLocale)
                {
                    isDefaultLocale = TRUE;
                    inLocale = uloc_getDefault();
                }
                else {
                    done = TRUE;
                }
            }
            
            
            bundle = ures_open(NULL, inLocale, &err);
            
            if (U_SUCCESS(err))
            {
                const UChar* temp = NULL;  
                UResourceBundle* langBundle;

                err = U_ZERO_ERROR;
                langBundle = ures_getByKey(bundle, _kLanguages, NULL, &err);
                if (U_SUCCESS(err))
                {
                    temp = ures_getStringByKey(langBundle,
                        inLanguageBuffer,
                        &resultLen,
                        &err);
                    resultLen++;
                    if (U_SUCCESS(err))
                        result = temp;
                    ures_close(langBundle);
                }
                ures_close(bundle);
            }
            
            
            err = U_ZERO_ERROR;
            
            /*Iterates down the Locale ID*/
            
            uloc_getParent(inLocale, inLocaleBuffer, TEMPBUFSIZE, &err);
            inLocale = inLocaleBuffer;
            
        } while ((result == NULL) && !done);
    }
    
    
    if (result)
    {
        if (resultLen > languageCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (languageCapacity >= 1) 
            {
                u_strncpy(language, result, languageCapacity-1);
                language[languageCapacity-1] = (UChar)0x0000;
            }
        }
        else {
            u_strcpy(language, result);
        }
    }
    else 
    {
        /*Falls back to ISO Name*/
        resultLen = langBufSize;
        if (resultLen > languageCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (languageCapacity >= 1) 
            {
                
                language[languageCapacity-1] = (UChar)0x0000;
                u_uastrncpy(language, inLanguageBuffer, languageCapacity-1);
            }
        }
        else u_uastrcpy(language, inLanguageBuffer);
    }
    return resultLen;
}

int32_t uloc_getDisplayCountry(const char* locale,
                   const char* inLocale,
                   UChar* country,
                   int32_t countryCapacity,
                   UErrorCode* status)
{
    /* NULL may be used to specify the default */
    const UChar* result = NULL;
    int32_t resultLen = 0;
    int cntryBufSize;
    char inCountryBuffer[TEMPBUFSIZE];
    UErrorCode err = U_ZERO_ERROR;
    UResourceBundle* bundle = NULL;
    char inLocaleBuffer[TEMPBUFSIZE];
    UBool isDefaultLocale = FALSE;
    UBool done = FALSE;
    
    if (U_FAILURE(*status))
        return 0;
    
    if (inLocale == NULL)    
    {
        inLocale = uloc_getDefault();
        isDefaultLocale = TRUE;
    }
    else if (uprv_strcmp(inLocale, uloc_getDefault()) == 0)
    {
        isDefaultLocale = TRUE;
    }
    /*truncates the fallback mechanism if we start out with a defaultLocale*/
    
    if (locale == NULL) {
        locale = uloc_getDefault();
    }
    
    /*extracts the country*/
    cntryBufSize = uloc_getCountry(locale, inCountryBuffer, TEMPBUFSIZE, &err);
    
    
    if (cntryBufSize > 1)
    {
        /*
        We need to implement a fallback mechanism here because we are getting keys out of a
        tagged array, there is no capability of doing this with fallback through the resource
        bundle API
        */
        do 
        {
            /*
            If we are at the root locale ("")
            The first time we fall back to the full default locale
            As we iterate down the latter, if we hit the root locale ("")
            we pass it to the resource bundle api so it checks default.txt
            */
            
            if (inLocale[0] == '\0')
            {
                if (!isDefaultLocale)
                {
                    isDefaultLocale = TRUE;
                    inLocale = uloc_getDefault();
                }
                else
                    done = TRUE;
            }
            
            
            bundle = ures_open(NULL, inLocale, &err);      
            
            if (U_SUCCESS(err))
            {
                const UChar* temp;
                UResourceBundle* countryBundle;

                err = U_ZERO_ERROR;
                countryBundle = ures_getByKey(bundle, _kCountries, NULL, &err);
                if (U_SUCCESS(err))
                {
                    temp = ures_getStringByKey(countryBundle,
                        inCountryBuffer,
                        &resultLen,
                        &err);
                    resultLen++;
                    if (U_SUCCESS(err))
                        result = temp;
                    ures_close(countryBundle);
                }
                ures_close(bundle);
            }
            
            err = U_ZERO_ERROR;
            uloc_getParent(inLocale, inLocaleBuffer, TEMPBUFSIZE, &err);
            
            inLocale = inLocaleBuffer;
        } while ((result == NULL) && !done);
    }
    
    if (result)
    {
        if (resultLen > countryCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (countryCapacity >= 1)
            {
                country[countryCapacity-1] = (UChar)0x0000;
                u_strncpy(country, result, countryCapacity-1);
            }
        }
        else u_strcpy(country, result);
    }
    else 
    {
        /*Falls back to ISO Name*/
        resultLen = cntryBufSize;
        if (resultLen > countryCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (countryCapacity >= 1) 
            {
                u_uastrncpy(country, inCountryBuffer, countryCapacity-1);
                country[countryCapacity-1] = (UChar)0x0000;
            }
        }
        else u_uastrcpy(country, inCountryBuffer);
    }
    
    return resultLen;
}

int32_t uloc_getDisplayVariant(const char* locale,
                   const char* inLocale,
                   UChar* variant,
                   int32_t variantCapacity,
                   UErrorCode* status)
{
    const UChar* result = NULL;
    int32_t resultLen = 0;
    int varBufSize;
    char inVariantBuffer[TEMPBUFSIZE];
    char* inVariant = inVariantBuffer;
    UErrorCode err = U_ZERO_ERROR;
    UResourceBundle* bundle;
    char inLocaleBuffer[TEMPBUFSIZE];
    UBool isDefaultLocale = FALSE;
    char inVariantTagBuffer[TEMPBUFSIZE+2];
    char* inVariantTag = inVariantTagBuffer;
    UBool done = FALSE;
    
    if (U_FAILURE(*status))
        return 0;
    
    inVariantTagBuffer[0] = '\0';
    
    if (inLocale == NULL)    
    {
        inLocale = uloc_getDefault();
        isDefaultLocale = TRUE;
    }
    else if (uprv_strcmp(inLocale, uloc_getDefault()) == 0)
    {
        isDefaultLocale = TRUE;
    }
    /*truncates the fallback mechanism if we start out with a defaultLocale*/
    
    if (locale == NULL)
        locale = uloc_getDefault();
    
    /*extracts the variant*/
    varBufSize = uloc_getVariant(locale, inVariant, TEMPBUFSIZE, &err);
    
    if (varBufSize > 1)
    {
        /*In case the variant is longer than our stack buffers*/
        if (err == U_BUFFER_OVERFLOW_ERROR)
        {
            inVariant = (char*)uprv_malloc(varBufSize*sizeof(char)+1);
            if (inVariant == NULL)
                goto NO_MEMORY;
            inVariantTag = (char*)uprv_malloc(varBufSize*sizeof(char)+uprv_strlen("%%")+1);
            if (inVariantTag == NULL) 
            {
                uprv_free(inVariant);
                goto NO_MEMORY;
            }
            err = U_ZERO_ERROR;
            uloc_getVariant(locale, inVariant, varBufSize, &err);
        }
        
        uprv_strcpy(inVariantTag,"%%");  
        uprv_strcat(inVariantTag, inVariant);
        
        /*We need to implement a fallback mechanism here because we are getting keys out of a
        tagged array, there is no capability of doing this with fallback through the resource
        bundle API*/
        do {
            /*
            If we are at the root locale ("")
            The first time we fall back to the full default locale
            As we iterate down the latter, if we hit the root locale ("")
            we pass it to the resource bundle api so it checks default.txt
            */
            
            if (inLocale[0] == '\0')
            {
                if (!isDefaultLocale)
                {
                    isDefaultLocale = TRUE;
                    inLocale = uloc_getDefault();
                }
                else
                    done = TRUE;
            }
            
            
            bundle = ures_open(NULL, inLocale, &err);      
            
            if (U_SUCCESS(err))
            {
                const UChar* temp;
                
                temp = ures_getStringByKey(bundle,
                    inVariantTag,
                    &resultLen,
                    &err);
                resultLen++;
                if (U_SUCCESS(err))
                    result = temp;
                ures_close(bundle);
            }
            
            err = U_ZERO_ERROR;
            uloc_getParent(inLocale, inLocaleBuffer, TEMPBUFSIZE, &err);
            
            inLocale = inLocaleBuffer;
        } while ((result == NULL) && !done);
    }
    
    
    if (result)
    {
        if (resultLen > variantCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (variantCapacity >= 1) 
            {
                variant[variantCapacity-1] = (UChar)0x0000;
                u_strncpy(variant, result, variantCapacity-1);
            }
        }
        else
        {
            u_strcpy(variant, result);
        }
    }
    else 
    {
        /*Falls back to user's Name*/
        resultLen = varBufSize;
        if (resultLen > variantCapacity)
        {
            *status = U_BUFFER_OVERFLOW_ERROR;
            
            if (variantCapacity >= 1) 
            {
                u_uastrncpy(variant, inVariant, variantCapacity-1);
                variant[variantCapacity-1] = (UChar)0x0000;
            }
        }
        else
        {
            u_uastrcpy(variant, inVariant);
        }
    }
    
    /*Clean up memory*/
    if (inVariant != inVariantBuffer)
    {
        uprv_free(inVariant);
        uprv_free(inVariantTag);
    } 
    return resultLen;
    
NO_MEMORY:
    *status = U_MEMORY_ALLOCATION_ERROR;
    return 0;
}

int32_t uloc_getDisplayName(const char* locale,
                const char* inLocale, 
                UChar* result,
                int32_t nameCapacity,
                UErrorCode* err) 
{
    UErrorCode int_err = U_ZERO_ERROR;
    int i = 0;
    int cntSze, varSze;
    UBool has_lang = TRUE;
    int result_size;
    
    int_err = U_ZERO_ERROR;
    
    /*Preflights all the components*/
    cntSze = uloc_getDisplayCountry(locale, 
        inLocale,
        NULL , 
        0,
        &int_err);
    int_err = U_ZERO_ERROR;
    varSze = uloc_getDisplayVariant(locale, 
        inLocale,
        NULL , 
        0,
        &int_err);
    
    int_err = U_ZERO_ERROR;
    i = uloc_getDisplayLanguage(locale, 
        inLocale,
        NULL,
        0, 
        &int_err);
    /*Decrement duplicative zero-terminators*/
    --varSze;
    --cntSze;
    
    /*Logic below adjusts pre-flight information with additional characters "(", ",", " ", ")"
    when neeed be*/
    if ((i-1 == 0) && (varSze == 0)) /*No language field*/
    {
        has_lang = FALSE;
        i = cntSze+1;
    }
    else if (cntSze)
    {
        if (varSze)
        {
            i += cntSze + varSze + 5;
        }
        else
        {
            i += cntSze + 3;
        }
    }
    
    int_err = U_ZERO_ERROR;
    
    result_size = uloc_getDisplayLanguage(locale, 
        inLocale,
        result,
        nameCapacity, 
        &int_err) - 1;
    
    if (U_SUCCESS(int_err)&&cntSze)
    {
        if (U_SUCCESS(int_err))
        {
            if (has_lang) 
            {
                u_strcat(result, openParen);
                result_size += 2;
            }
            
            result_size += uloc_getDisplayCountry(locale,
                inLocale,
                result + result_size,
                nameCapacity - result_size,
                &int_err) - 1;
        }
        
        if (varSze)
        {
            if (U_SUCCESS(int_err))      
            {
                u_strcat(result, comma);
                result_size += 2;
                
                result_size += uloc_getDisplayVariant(locale,
                    inLocale,
                    result + result_size,
                    nameCapacity - result_size, 
                    &int_err) - 1;
            }
        }
        
        if (U_SUCCESS(int_err)&&has_lang)
        {
            u_strcat(result, closeParen);
        }
    }
    
    *err  = int_err;
    
    return i;
}

const char*
uloc_getAvailable(int32_t offset) 
{
    
    if (_installedLocales == NULL)
        _lazyEvaluate_installedLocales();
    
    if (offset > _installedLocalesCount)
        return NULL;
    else
        return _installedLocales[offset];

}

int32_t uloc_countAvailable()
{
  if (_installedLocales == NULL) _lazyEvaluate_installedLocales();

    return _installedLocalesCount;
}

static void _lazyEvaluate_installedLocales()
{
    UResourceBundle *index = NULL;
    UResourceBundle installed;
    UErrorCode status = U_ZERO_ERROR;
    const UChar *lname;
    char ** temp;
    int32_t i = 0;
    int32_t len = 0;
    
    ures_setIsStackObject(&installed, TRUE);
    index = ures_open(NULL, kIndexLocaleName, &status);
    ures_getByKey(index, kIndexTag, &installed, &status);
    
    if(U_SUCCESS(status)) {
        _installedLocalesCount = ures_getSize(&installed);
        temp = (char **) uprv_malloc(sizeof(char*) * (_installedLocalesCount+1));
        
        ures_resetIterator(&installed);
        while(ures_hasNext(&installed)) {
            lname = ures_getNextString(&installed, &len, NULL, &status);
            temp[i] = (char*) uprv_malloc(sizeof(char) * (len + 1));
            
            u_UCharsToChars(lname, temp[i], len);
            temp[i][len] = 0; /* Terminate the string */
            i++;
        }
        {
            umtx_lock(NULL);
            if (_installedLocales == NULL)
            {
                _installedLocales = temp;
                temp = NULL;
            } else {
                for (i = 0; i < _installedLocalesCount; i++) uprv_free(temp[i]);
                uprv_free(temp);
            }
            umtx_unlock(NULL);
            
        }
        ures_close(&installed);
    }
    ures_close(index);
}

/**
 * Returns a list of all language codes defined in ISO 639.  This is a pointer
 * to an array of pointers to arrays of char.  All of these pointers are owned
 * by ICU-- do not delete them, and do not write through them.  The array is
 * terminated with a null pointer.
 */
const char* const* uloc_getISOLanguages() 
{
    const char *from, *end;
    char **to;
    
    if (_isoLanguages == NULL) 
    {
        
        {
            umtx_lock(NULL);
            
            if (_isoLanguages == NULL) 
            {
                _isoLanguages = (char**) uprv_malloc(sizeof(char*)*(1+(sizeof(_languages) / 3)));
                
                end = _languages + (sizeof(_languages));
                from = _languages; 
                to = _isoLanguages;
                
                while (from < end) 
                {
                    *to = (char*)from;
                    ++to;
                    from += 3;
                }
                *to = NULL;
            }
            umtx_unlock(NULL);
        }
    }
    return (const char* const*)_isoLanguages;
}

/**
 * Returns a list of all 2-letter country codes defined in ISO 639.  This is a
 * pointer to an array of pointers to arrays of char.  All of these pointers are
 * owned by ICU-- do not delete them, and do not write through them.  The array is
 * terminated with a null pointer.
 */
const char* const* uloc_getISOCountries() 
{
    if (_isoCountries == NULL) 
    {
        const char *from, *end;
        char **to;
        {
            umtx_lock(NULL);
            
            if (_isoCountries == NULL) 
            {
                _isoCountries = (char**) uprv_malloc(sizeof(char*)*(1+(sizeof(_countries) / 3)));
                
                end = _countries + (sizeof(_countries));
                from = _countries;
                to = _isoCountries;
                
                while (from < end) 
                {
                    *to = (char*)from;
                    ++to;
                    from += 3;
                }
                *to = NULL;
            }
            umtx_unlock(NULL);
        }
    }
    return (const char* const*)_isoCountries;
}