1 files changed, 322 insertions, 0 deletions
diff --git a/deps/icu-small/source/i18n/numsys.cpp b/deps/icu-small/source/i18n/numsys.cpp
new file mode 100644
index 0000000000..498a8b3891
--- /dev/null
+++ b/deps/icu-small/source/i18n/numsys.cpp
@@ -0,0 +1,322 @@
+/*
+*******************************************************************************
+* Copyright (C) 2010-2015, International Business Machines Corporation and
+* others. All Rights Reserved.
+*******************************************************************************
+*
+*
+* File NUMSYS.CPP
+*
+* Modification History:*
+*   Date        Name        Description
+*
+********************************************************************************
+*/
+
+#include "unicode/utypes.h"
+#include "unicode/localpointer.h"
+#include "unicode/uchar.h"
+#include "unicode/unistr.h"
+#include "unicode/ures.h"
+#include "unicode/ustring.h"
+#include "unicode/uloc.h"
+#include "unicode/schriter.h"
+#include "unicode/numsys.h"
+#include "cstring.h"
+#include "uresimp.h"
+#include "numsys_impl.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+U_NAMESPACE_BEGIN
+
+// Useful constants
+
+#define DEFAULT_DIGITS UNICODE_STRING_SIMPLE("0123456789");
+static const char gNumberingSystems[] = "numberingSystems";
+static const char gNumberElements[] = "NumberElements";
+static const char gDefault[] = "default";
+static const char gNative[] = "native";
+static const char gTraditional[] = "traditional";
+static const char gFinance[] = "finance";
+static const char gDesc[] = "desc";
+static const char gRadix[] = "radix";
+static const char gAlgorithmic[] = "algorithmic";
+static const char gLatn[] = "latn";
+
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NumberingSystem)
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NumsysNameEnumeration)
+
+    /**
+     * Default Constructor.
+     *
+     * @draft ICU 4.2
+     */
+
+NumberingSystem::NumberingSystem() {
+     radix = 10;
+     algorithmic = FALSE;
+     UnicodeString defaultDigits = DEFAULT_DIGITS;
+     desc.setTo(defaultDigits);
+     uprv_strcpy(name,gLatn);
+}
+
+    /**
+     * Copy constructor.
+     * @draft ICU 4.2
+     */
+
+NumberingSystem::NumberingSystem(const NumberingSystem& other)
+:  UObject(other) {
+    *this=other;
+}
+
+NumberingSystem* U_EXPORT2
+NumberingSystem::createInstance(int32_t radix_in, UBool isAlgorithmic_in, const UnicodeString & desc_in, UErrorCode &status) {
+
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+
+    if ( radix_in < 2 ) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return NULL;
+    }
+
+    if ( !isAlgorithmic_in ) {
+       if ( desc_in.countChar32() != radix_in ) {
+           status = U_ILLEGAL_ARGUMENT_ERROR;
+           return NULL;
+       }
+    }
+
+    NumberingSystem *ns = new NumberingSystem();
+
+    ns->setRadix(radix_in);
+    ns->setDesc(desc_in);
+    ns->setAlgorithmic(isAlgorithmic_in);
+    ns->setName(NULL);
+    return ns;
+
+}
+
+
+NumberingSystem* U_EXPORT2
+NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) {
+
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+
+    UBool nsResolved = TRUE;
+    UBool usingFallback = FALSE;
+    char buffer[ULOC_KEYWORDS_CAPACITY];
+    int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status);
+    if ( count > 0 ) { // @numbers keyword was specified in the locale
+        buffer[count] = '\0'; // Make sure it is null terminated.
+        if ( !uprv_strcmp(buffer,gDefault) || !uprv_strcmp(buffer,gNative) ||
+             !uprv_strcmp(buffer,gTraditional) || !uprv_strcmp(buffer,gFinance)) {
+            nsResolved = FALSE;
+        }
+    } else {
+        uprv_strcpy(buffer,gDefault);
+        nsResolved = FALSE;
+    }
+
+    if (!nsResolved) { // Resolve the numbering system ( default, native, traditional or finance ) into a "real" numbering system
+        UErrorCode localStatus = U_ZERO_ERROR;
+        UResourceBundle *resource = ures_open(NULL, inLocale.getName(), &localStatus);
+        UResourceBundle *numberElementsRes = ures_getByKey(resource,gNumberElements,NULL,&localStatus);
+        while (!nsResolved) {
+            localStatus = U_ZERO_ERROR;
+            count = 0;
+            const UChar *nsName = ures_getStringByKeyWithFallback(numberElementsRes, buffer, &count, &localStatus);
+            if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // numbering system found
+                u_UCharsToChars(nsName,buffer,count);
+                buffer[count] = '\0'; // Make sure it is null terminated.
+                nsResolved = TRUE;
+            }
+
+            if (!nsResolved) { // Fallback behavior per TR35 - traditional falls back to native, finance and native fall back to default
+                if (!uprv_strcmp(buffer,gNative) || !uprv_strcmp(buffer,gFinance)) {
+                    uprv_strcpy(buffer,gDefault);
+                } else if (!uprv_strcmp(buffer,gTraditional)) {
+                    uprv_strcpy(buffer,gNative);
+                } else { // If we get here we couldn't find even the default numbering system
+                    usingFallback = TRUE;
+                    nsResolved = TRUE;
+                }
+            }
+        }
+        ures_close(numberElementsRes);
+        ures_close(resource);
+    }
+
+    if (usingFallback) {
+        status = U_USING_FALLBACK_WARNING;
+        NumberingSystem *ns = new NumberingSystem();
+        return ns;
+    } else {
+        return NumberingSystem::createInstanceByName(buffer,status);
+    }
+ }
+
+NumberingSystem* U_EXPORT2
+NumberingSystem::createInstance(UErrorCode& status) {
+    return NumberingSystem::createInstance(Locale::getDefault(), status);
+}
+
+NumberingSystem* U_EXPORT2
+NumberingSystem::createInstanceByName(const char *name, UErrorCode& status) {
+    UResourceBundle *numberingSystemsInfo = NULL;
+    UResourceBundle *nsTop, *nsCurrent;
+    int32_t radix = 10;
+    int32_t algorithmic = 0;
+
+    numberingSystemsInfo = ures_openDirect(NULL,gNumberingSystems, &status);
+    nsCurrent = ures_getByKey(numberingSystemsInfo,gNumberingSystems,NULL,&status);
+    nsTop = ures_getByKey(nsCurrent,name,NULL,&status);
+    UnicodeString nsd = ures_getUnicodeStringByKey(nsTop,gDesc,&status);
+
+    ures_getByKey(nsTop,gRadix,nsCurrent,&status);
+    radix = ures_getInt(nsCurrent,&status);
+
+    ures_getByKey(nsTop,gAlgorithmic,nsCurrent,&status);
+    algorithmic = ures_getInt(nsCurrent,&status);
+
+    UBool isAlgorithmic = ( algorithmic == 1 );
+
+    ures_close(nsCurrent);
+    ures_close(nsTop);
+    ures_close(numberingSystemsInfo);
+
+    if (U_FAILURE(status)) {
+        status = U_UNSUPPORTED_ERROR;
+        return NULL;
+    }
+
+    NumberingSystem* ns = NumberingSystem::createInstance(radix,isAlgorithmic,nsd,status);
+    ns->setName(name);
+    return ns;
+}
+
+    /**
+     * Destructor.
+     * @draft ICU 4.2
+     */
+NumberingSystem::~NumberingSystem() {
+}
+
+int32_t NumberingSystem::getRadix() const {
+    return radix;
+}
+
+UnicodeString NumberingSystem::getDescription() const {
+    return desc;
+}
+
+const char * NumberingSystem::getName() const {
+    return name;
+}
+
+void NumberingSystem::setRadix(int32_t r) {
+    radix = r;
+}
+
+void NumberingSystem::setAlgorithmic(UBool c) {
+    algorithmic = c;
+}
+
+void NumberingSystem::setDesc(UnicodeString d) {
+    desc.setTo(d);
+}
+void NumberingSystem::setName(const char *n) {
+    if ( n == NULL ) {
+        name[0] = (char) 0;
+    } else {
+        uprv_strncpy(name,n,NUMSYS_NAME_CAPACITY);
+        name[NUMSYS_NAME_CAPACITY] = (char)0; // Make sure it is null terminated.
+    }
+}
+UBool NumberingSystem::isAlgorithmic() const {
+    return ( algorithmic );
+}
+
+StringEnumeration* NumberingSystem::getAvailableNames(UErrorCode &status) {
+    // TODO(ticket #11908): Init-once static cache, with u_cleanup() callback.
+    static StringEnumeration* availableNames = NULL;
+
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+
+    if ( availableNames == NULL ) {
+        // TODO: Simple array of UnicodeString objects, based on length of table resource?
+        LocalPointer<UVector> numsysNames(new UVector(uprv_deleteUObject, NULL, status), status);
+        if (U_FAILURE(status)) {
+            return NULL;
+        }
+
+        UErrorCode rbstatus = U_ZERO_ERROR;
+        UResourceBundle *numberingSystemsInfo = ures_openDirect(NULL, "numberingSystems", &rbstatus);
+        numberingSystemsInfo = ures_getByKey(numberingSystemsInfo,"numberingSystems",numberingSystemsInfo,&rbstatus);
+        if(U_FAILURE(rbstatus)) {
+            status = U_MISSING_RESOURCE_ERROR;
+            ures_close(numberingSystemsInfo);
+            return NULL;
+        }
+
+        while ( ures_hasNext(numberingSystemsInfo) ) {
+            UResourceBundle *nsCurrent = ures_getNextResource(numberingSystemsInfo,NULL,&rbstatus);
+            const char *nsName = ures_getKey(nsCurrent);
+            numsysNames->addElement(new UnicodeString(nsName, -1, US_INV),status);
+            ures_close(nsCurrent);
+        }
+
+        ures_close(numberingSystemsInfo);
+        if (U_FAILURE(status)) {
+            return NULL;
+        }
+        availableNames = new NumsysNameEnumeration(numsysNames.getAlias(), status);
+        if (availableNames == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return NULL;
+        }
+        numsysNames.orphan();  // The names got adopted.
+    }
+
+    return availableNames;
+}
+
+NumsysNameEnumeration::NumsysNameEnumeration(UVector *numsysNames, UErrorCode& /*status*/) {
+    pos=0;
+    fNumsysNames = numsysNames;
+}
+
+const UnicodeString*
+NumsysNameEnumeration::snext(UErrorCode& status) {
+    if (U_SUCCESS(status) && pos < fNumsysNames->size()) {
+        return (const UnicodeString*)fNumsysNames->elementAt(pos++);
+    }
+    return NULL;
+}
+
+void
+NumsysNameEnumeration::reset(UErrorCode& /*status*/) {
+    pos=0;
+}
+
+int32_t
+NumsysNameEnumeration::count(UErrorCode& /*status*/) const {
+    return (fNumsysNames==NULL) ? 0 : fNumsysNames->size();
+}
+
+NumsysNameEnumeration::~NumsysNameEnumeration() {
+    delete fNumsysNames;
+}
+U_NAMESPACE_END
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
+//eof