/** * Override this method to perform any custom logic when a variable assignment is found. Note that the same * variable may be assigned different values at different times within the same function. * The symbol will be constructed in the following way: * * Example assignment: $name = $this->getName()->toString(); * * Variable: The variable's ChainList will contain the variable's name in index 0: "$name" * ChainList: This is a list of properties / methods * that were successively invoked. * In this example, the expression chain list will have 3 items in * the chain list "$this" "->getName()" and "->toString()". * * The variable itself may contain an array key in it; like so: $person['name'] = $this->getName()->toString(); * In this case, Variable ChainList will contain 1 item: "$name" and the Variable Array Key will contain "name" * * * @param const UnicodeString& namespace the fully qualified namespace of the containing class / function. * @param const UnicodeString& className class where the variable was found. may be empty is variable is scoped * inside a function or is global. * @param const UnicodeString& methodName function/method name where the variable was found. may be empty if * variable is globally scoped. * @param const VariableClass& variable the name of the variable that was found, along with any array keys that were used * in the left hand of the assignment. * @param const ExpressionClass& expression the expression assigned to the variable * @param const UnicodeString& comment PHPDoc attached to the variable * * @see pelet::VariableClass */ virtual void VariableFound(const UnicodeString& namespaceName, const UnicodeString& className, const UnicodeString& methodName, const pelet::VariableClass& variable, pelet::ExpressionClass* expression, const UnicodeString& comment) { UFILE* ufout = u_finit(stdout, NULL, NULL); UnicodeString scope; if (className.isEmpty() && methodName.isEmpty()) { scope = UNICODE_STRING_SIMPLE("<global>"); } else if (className.isEmpty() && !methodName.isEmpty()) { scope = methodName; } else { scope = className + UNICODE_STRING_SIMPLE("::") + methodName; } UnicodeString type; if (variable.IsPhpDocVariable && !variable.PhpDocType.isEmpty()) { type += UNICODE_STRING_SIMPLE("Variable is decorated with a PHPDoc comment: "); type += variable.PhpDocType; } else if (pelet::ExpressionClass::ARRAY == expression->ExpressionType) { type = UNICODE_STRING_SIMPLE("Variable is an array"); } else if (pelet::ExpressionClass::SCALAR == expression->ExpressionType) { type = UNICODE_STRING_SIMPLE("Variable is a primitive"); } else if (pelet::ExpressionClass::VARIABLE == expression->ExpressionType) { type = UNICODE_STRING_SIMPLE("Variable is a variable expression. "); type += UNICODE_STRING_SIMPLE("Chain list is: "); pelet::VariableClass* srcVariable = (pelet::VariableClass*) expression; for (size_t i = 0; i < srcVariable->ChainList.size(); ++i) { if (srcVariable->ChainList[i].IsStatic && i > 0) { type += UNICODE_STRING_SIMPLE("::"); } else if (i > 0) { type += UNICODE_STRING_SIMPLE("->"); } type += srcVariable->ChainList[i].Name; if (srcVariable->ChainList[i].IsFunction) { type += UNICODE_STRING_SIMPLE("()"); } if (i < (srcVariable->ChainList.size() - 1)) { type += UNICODE_STRING_SIMPLE(", "); } } } else if (pelet::ExpressionClass::UNKNOWN == expression->ExpressionType) { type = UNICODE_STRING_SIMPLE("Variable is of unknown type."); } u_fprintf(ufout, "Variable Found: %.*S in scope %S. %S\n", variable.ChainList[0].Name.length(), variable.ChainList[0].Name.getBuffer(), scope.getTerminatedBuffer(), type.getTerminatedBuffer()); }
bool t4p::WorkingCacheClass::Update(const UnicodeString& code, const t4p::SymbolTableClass& previousSymbolTable) { pelet::LintResultsClass results; // allow empty code to be valid; that way code completion works // on newly created files bool ret = false; if (!code.isEmpty()) { ret = SymbolTable.CreateSymbols(code, previousSymbolTable); } else if (code.isEmpty()) { ret = true; } return ret; }
// A default, lightweight implementation of getDisplayNames. // Overridden in tznames_impl.cpp. void TimeZoneNames::getDisplayNames(const UnicodeString& tzID, const UTimeZoneNameType types[], int32_t numTypes, UDate date, UnicodeString dest[], UErrorCode& status) const { if (U_FAILURE(status)) { return; } if (tzID.isEmpty()) { return; } UnicodeString mzID; for (int i = 0; i < numTypes; i++) { getTimeZoneDisplayName(tzID, types[i], dest[i]); if (dest[i].isEmpty()) { if (mzID.isEmpty()) { getMetaZoneID(tzID, date, mzID); } getMetaZoneDisplayName(mzID, types[i], dest[i]); } } }
void UnicodeTest::TestScriptMetadata() { IcuTestErrorCode errorCode(*this, "TestScriptMetadata()"); UnicodeSet rtl("[[:bc=R:][:bc=AL:]-[:Cn:]-[:sc=Common:]]", errorCode); // So far, sample characters are uppercase. // Georgian is special. UnicodeSet cased("[[:Lu:]-[:sc=Common:]-[:sc=Geor:]]", errorCode); for(int32_t sci = 0; sci < USCRIPT_CODE_LIMIT; ++sci) { UScriptCode sc = (UScriptCode)sci; // Run the test with -v to see which script has failures: // .../intltest$ make && ./intltest utility/UnicodeTest/TestScriptMetadata -v | grep -C 3 FAIL logln(uscript_getShortName(sc)); UScriptUsage usage = uscript_getUsage(sc); UnicodeString sample = uscript_getSampleUnicodeString(sc); UnicodeSet scriptSet; scriptSet.applyIntPropertyValue(UCHAR_SCRIPT, sc, errorCode); if(usage == USCRIPT_USAGE_NOT_ENCODED) { assertTrue("not encoded, no sample", sample.isEmpty()); assertFalse("not encoded, not RTL", uscript_isRightToLeft(sc)); assertFalse("not encoded, not LB letters", uscript_breaksBetweenLetters(sc)); assertFalse("not encoded, not cased", uscript_isCased(sc)); assertTrue("not encoded, no characters", scriptSet.isEmpty()); } else { assertFalse("encoded, has a sample character", sample.isEmpty()); UChar32 firstChar = sample.char32At(0); UScriptCode charScript = getCharScript(sc); assertEquals("script(sample(script))", charScript, uscript_getScript(firstChar, errorCode)); assertEquals("RTL vs. set", rtl.contains(firstChar), uscript_isRightToLeft(sc)); assertEquals("cased vs. set", cased.contains(firstChar), uscript_isCased(sc)); assertEquals("encoded, has characters", sc == charScript, !scriptSet.isEmpty()); if(uscript_isRightToLeft(sc)) { rtl.removeAll(scriptSet); } if(uscript_isCased(sc)) { cased.removeAll(scriptSet); } } } UnicodeString pattern; assertEquals("no remaining RTL characters", UnicodeString("[]"), rtl.toPattern(pattern)); assertEquals("no remaining cased characters", UnicodeString("[]"), cased.toPattern(pattern)); assertTrue("Hani breaks between letters", uscript_breaksBetweenLetters(USCRIPT_HAN)); assertTrue("Thai breaks between letters", uscript_breaksBetweenLetters(USCRIPT_THAI)); assertFalse("Latn does not break between letters", uscript_breaksBetweenLetters(USCRIPT_LATIN)); }
std::vector<t4p::PhpTagClass> t4p::TagCacheClass::AllMemberTags(const UnicodeString& fullyQualifiedClassName, int fileTagId, std::vector<wxFileName>& sourceDirs) { std::vector<t4p::PhpTagClass> allMatches; // add the double colon so that we search for all members // first search for all members of the given class that is also in the given file t4p::TagSearchClass tagSearch(fullyQualifiedClassName + UNICODE_STRING_SIMPLE("::")); tagSearch.SetFileItemId(fileTagId); tagSearch.SetTraits(TagFinderList->ClassUsedTraits(fullyQualifiedClassName, tagSearch.GetParentClasses(), tagSearch.GetMethodName(), sourceDirs)); TagFinderList->NearMatchesFromAll(tagSearch, allMatches, sourceDirs); // now get all parent class (look in all files) also look for inherited members and traits UnicodeString parentClassName = TagFinderList->ParentClassName(fullyQualifiedClassName, fileTagId); if (!parentClassName.isEmpty()) { t4p::TagSearchClass hierarchySearch(parentClassName + UNICODE_STRING_SIMPLE("::")); hierarchySearch.SetParentClasses(TagFinderList->ClassParents(parentClassName, hierarchySearch.GetMethodName())); hierarchySearch.SetTraits(TagFinderList->ClassUsedTraits(parentClassName, hierarchySearch.GetParentClasses(), hierarchySearch.GetMethodName(), sourceDirs)); // search classes from the enabled source directories only hierarchySearch.SetSourceDirs(sourceDirs); TagFinderList->NearMatchesFromAll(hierarchySearch, allMatches, sourceDirs); TagFinderList->NearMatchTraitAliasesFromAll(hierarchySearch, allMatches); } return allMatches; }
UnicodeString& U_EXPORT2 ZoneMeta::getSingleCountry(const UnicodeString &tzid, UnicodeString &country) { UErrorCode status = U_ZERO_ERROR; // Get canonical country for the zone getCanonicalCountry(tzid, country); if (!country.isEmpty()) { UResourceBundle *supplementalDataBundle = ures_openDirect(NULL, gSupplementalData, &status); UResourceBundle *zoneFormatting = ures_getByKey(supplementalDataBundle, gZoneFormattingTag, NULL, &status); UResourceBundle *multizone = ures_getByKey(zoneFormatting, gMultizoneTag, NULL, &status); if (U_SUCCESS(status)) { while (ures_hasNext(multizone)) { int32_t len; const UChar* multizoneCountry = ures_getNextString(multizone, &len, NULL, &status); if (country.compare(multizoneCountry, len) == 0) { // Included in the multizone country list country.remove(); break; } } } ures_close(multizone); ures_close(zoneFormatting); ures_close(supplementalDataBundle); } return country; }
/* {{{ intl_charFromString * faster than doing intl_convert_utf16_to_utf8(&res, &res_len, * from.getBuffer(), from.length(), &status), * but consumes more memory */ int intl_charFromString(const UnicodeString &from, char **res, int *res_len, UErrorCode *status) { if (from.isBogus()) { return FAILURE; } //the number of UTF-8 code units is not larger than that of UTF-16 code //units * 3 + 1 for the terminator int32_t capacity = from.length() * 3 + 1; if (from.isEmpty()) { *res = (char*)emalloc(1); **res = '\0'; *res_len = 0; return SUCCESS; } *res = (char*)emalloc(capacity); *res_len = 0; //tbd const UChar *utf16buf = from.getBuffer(); int32_t actual_len; u_strToUTF8WithSub(*res, capacity - 1, &actual_len, utf16buf, from.length(), U_SENTINEL, NULL, status); if (U_FAILURE(*status)) { efree(*res); *res = NULL; return FAILURE; } (*res)[actual_len] = '\0'; *res_len = (int)actual_len; return SUCCESS; }
UBool AlphabeticIndex::addChineseIndexCharacters(UErrorCode &errorCode) { UnicodeSet contractions; ucol_getContractionsAndExpansions(collatorPrimaryOnly_->getUCollator(), contractions.toUSet(), NULL, FALSE, &errorCode); if (U_FAILURE(errorCode)) { return FALSE; } UnicodeString firstHanBoundary; UBool hasPinyin = FALSE; UnicodeSetIterator iter(contractions); while (iter.next()) { const UnicodeString &s = iter.getString(); if (s.startsWith(BASE, BASE_LENGTH)) { initialLabels_->add(s); if (firstHanBoundary.isEmpty() || collatorPrimaryOnly_->compare(s, firstHanBoundary, errorCode) < 0) { firstHanBoundary = s; } UChar c = s.charAt(s.length() - 1); if (0x41 <= c && c <= 0x5A) { // A-Z hasPinyin = TRUE; } } } if (hasPinyin) { initialLabels_->add(0x41, 0x5A); // A-Z } if (!firstHanBoundary.isEmpty()) { // The hardcoded list of script boundaries includes U+4E00 // which is tailored to not be the first primary // in all Chinese tailorings except "unihan". // Replace U+4E00 with the first boundary string from the tailoring. // TODO: This becomes obsolete when the root collator gets // reliable script-first-primary mappings. int32_t hanIndex = binarySearch( *firstCharsInScripts_, UnicodeString((UChar)0x4E00), *collatorPrimaryOnly_); if (hanIndex >= 0) { UnicodeString *fh = new UnicodeString(firstHanBoundary); if (fh == NULL) { errorCode = U_MEMORY_ALLOCATION_ERROR; return FALSE; } firstCharsInScripts_->setElementAt(fh, hanIndex); } return TRUE; } else { return FALSE; } }
UBool FCDUIterCollationIterator::previousSegment(UErrorCode &errorCode) { if(U_FAILURE(errorCode)) { return FALSE; } U_ASSERT(state == ITER_CHECK_BWD); // The input text [(iter index)..limit[ passes the FCD check. pos = iter.getIndex(&iter, UITER_CURRENT); // Collect the characters being checked, in case they need to be normalized. UnicodeString s; uint8_t nextCC = 0; for(;;) { // Fetch the previous character and its fcd16 value. UChar32 c = uiter_previous32(&iter); if(c < 0) { break; } uint16_t fcd16 = nfcImpl.getFCD16(c); uint8_t trailCC = (uint8_t)fcd16; if(trailCC == 0 && !s.isEmpty()) { // FCD boundary after this character. uiter_next32(&iter); break; } s.append(c); if(trailCC != 0 && ((nextCC != 0 && trailCC > nextCC) || CollationFCD::isFCD16OfTibetanCompositeVowel(fcd16))) { // Fails FCD check. Find the previous FCD boundary and normalize. while(fcd16 > 0xff) { c = uiter_previous32(&iter); if(c < 0) { break; } fcd16 = nfcImpl.getFCD16(c); if(fcd16 == 0) { (void)uiter_next32(&iter); break; } s.append(c); } s.reverse(); if(!normalize(s, errorCode)) { return FALSE; } limit = pos; start = pos - s.length(); state = IN_NORM_ITER_AT_START; pos = normalized.length(); return TRUE; } nextCC = (uint8_t)(fcd16 >> 8); if(nextCC == 0) { // FCD boundary before the following character. break; } } start = pos - s.length(); U_ASSERT(pos != start); iter.move(&iter, s.length(), UITER_CURRENT); state = ITER_IN_FCD_SEGMENT; return TRUE; }
std::string GlobalizationNDK::getPreferredLanguage() { const Locale& loc = Locale::getDefault(); UnicodeString disp; loc.getDisplayLanguage(loc, disp); if (disp.isEmpty()) return resultInJson("English"); // FIXME: what should be the default language? std::string utf8; disp.toUTF8String(utf8); return resultInJson(utf8); }
UBool FCDUIterCollationIterator::nextSegment(UErrorCode &errorCode) { if(U_FAILURE(errorCode)) { return FALSE; } U_ASSERT(state == ITER_CHECK_FWD); // The input text [start..(iter index)[ passes the FCD check. pos = iter.getIndex(&iter, UITER_CURRENT); // Collect the characters being checked, in case they need to be normalized. UnicodeString s; uint8_t prevCC = 0; for(;;) { // Fetch the next character and its fcd16 value. UChar32 c = uiter_next32(&iter); if(c < 0) { break; } uint16_t fcd16 = nfcImpl.getFCD16(c); uint8_t leadCC = (uint8_t)(fcd16 >> 8); if(leadCC == 0 && !s.isEmpty()) { // FCD boundary before this character. uiter_previous32(&iter); break; } s.append(c); if(leadCC != 0 && (prevCC > leadCC || CollationFCD::isFCD16OfTibetanCompositeVowel(fcd16))) { // Fails FCD check. Find the next FCD boundary and normalize. for(;;) { c = uiter_next32(&iter); if(c < 0) { break; } if(nfcImpl.getFCD16(c) <= 0xff) { uiter_previous32(&iter); break; } s.append(c); } if(!normalize(s, errorCode)) { return FALSE; } start = pos; limit = pos + s.length(); state = IN_NORM_ITER_AT_LIMIT; pos = 0; return TRUE; } prevCC = (uint8_t)fcd16; if(prevCC == 0) { // FCD boundary after the last character. break; } } limit = pos + s.length(); U_ASSERT(pos != limit); iter.move(&iter, -s.length(), UITER_CURRENT); state = ITER_IN_FCD_SEGMENT; return TRUE; }
void ResourceBundle::constructForLocale(const UnicodeString& path, const Locale& locale, UErrorCode& error) { if (path.isEmpty()) { fResource = ures_open(NULL, locale.getName(), &error); } else { UnicodeString nullTerminatedPath(path); nullTerminatedPath.append((UChar)0); fResource = ures_openU(nullTerminatedPath.getBuffer(), locale.getName(), &error); } }
// Merge the MZ_PREFIX and mzId static void mergeTimeZoneKey(const UnicodeString& mzID, char* result) { if (mzID.isEmpty()) { result[0] = '\0'; return; } char mzIdChar[ZID_KEY_MAX + 1]; int32_t keyLen; int32_t prefixLen = uprv_strlen(gMZPrefix); keyLen = mzID.extract(0, mzID.length(), mzIdChar, ZID_KEY_MAX + 1, US_INV); uprv_memcpy((void *)result, (void *)gMZPrefix, prefixLen); uprv_memcpy((void *)(result + prefixLen), (void *)mzIdChar, keyLen); result[keyLen + prefixLen] = '\0'; }
status_t ICULocaleconvData::_SetLocaleconvEntry(const DecimalFormatSymbols* formatSymbols, char* destination, FormatSymbol symbol, const char* defaultValue) { status_t result = B_OK; UnicodeString symbolString = formatSymbols->getSymbol(symbol); if (!symbolString.isEmpty()) { result = _ConvertUnicodeStringToLocaleconvEntry(symbolString, destination, skLCBufSize, defaultValue); } else destination[0] = '\0'; return result; }
UnicodeString &SimpleFormatter::formatAndReplace( const UnicodeString *const *values, int32_t valuesLength, UnicodeString &result, int32_t *offsets, int32_t offsetsLength, UErrorCode &errorCode) const { if (U_FAILURE(errorCode)) { return result; } if (isInvalidArray(values, valuesLength) || isInvalidArray(offsets, offsetsLength)) { errorCode = U_ILLEGAL_ARGUMENT_ERROR; return result; } const UChar *cp = compiledPattern.getBuffer(); int32_t cpLength = compiledPattern.length(); if (valuesLength < getArgumentLimit(cp, cpLength)) { errorCode = U_ILLEGAL_ARGUMENT_ERROR; return result; } // If the pattern starts with an argument whose value is the same object // as the result, then we keep the result contents and append to it. // Otherwise we replace its contents. int32_t firstArg = -1; // If any non-initial argument value is the same object as the result, // then we first copy its contents and use that instead while formatting. UnicodeString resultCopy; if (getArgumentLimit(cp, cpLength) > 0) { for (int32_t i = 1; i < cpLength;) { int32_t n = cp[i++]; if (n < ARG_NUM_LIMIT) { if (values[n] == &result) { if (i == 2) { firstArg = n; } else if (resultCopy.isEmpty() && !result.isEmpty()) { resultCopy = result; } } } else { i += n - ARG_NUM_LIMIT; } } } if (firstArg < 0) { result.remove(); } return format(cp, cpLength, values, result, &resultCopy, FALSE, offsets, offsetsLength, errorCode); }
/** * Override this method to perform custom logic when a trait method has been aliased * * @param const UnicodeString& namespace the fully qualified namespace of the class that uses the trait * @param traitUsedClassName the class name of the trait to be aliased * @param traitMethodName the fully qualified name of the trait method that is to be aliased (hidden) * this may be empty if the trait adaptation only changes the visibility and * does not need to resolve a trait conflict * @param alias the name of the new alias. alias may be empty when ONLY the visibility is changed. * @param visibility the visbility of the trait method. may be PUBLIC if the visibility was not changed. */ virtual void TraitAliasFound(const UnicodeString& namespaceName, const UnicodeString& className, const UnicodeString& traitUsedClassName, const UnicodeString& traitMethodName, const UnicodeString& alias, pelet::TokenClass::TokenIds visibility) { UFILE* ufout = u_finit(stdout, NULL, NULL); if (!alias.isEmpty()) { const char* visibilityStr; if (pelet::TokenClass::PRIVATE == visibility) { visibilityStr = "private"; } else if (pelet::TokenClass::PROTECTED == visibility) { visibilityStr = "protected"; } else { visibilityStr = "public"; } u_fprintf(ufout, "Trait Alias Found in class %.*S in namespace %.*S. Trait Class %.*S Trait Method %.*S Trait Alias %.*S New Visibility %s \n", className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), traitUsedClassName.length(), traitUsedClassName.getBuffer(), traitMethodName.length(), traitMethodName.getBuffer(), alias.length(), alias.getBuffer(), visibilityStr ); } else { const char* visibilityStr; if (pelet::TokenClass::PRIVATE == visibility) { visibilityStr = "private"; } else if (pelet::TokenClass::PROTECTED == visibility) { visibilityStr = "protected"; } else { visibilityStr = "public"; } u_fprintf(ufout, "Trait Change in visbility Found in class %.*S in namespace %.*S. Trait Class %.*S Trait Method %.*S New Visibility %s\n", className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), traitUsedClassName.length(), traitUsedClassName.getBuffer(), traitMethodName.length(), traitMethodName.getBuffer(), visibilityStr ); } u_fclose(ufout); }
UnicodeString& U_EXPORT2 TimeZoneNamesImpl::getDefaultExemplarLocationName(const UnicodeString& tzID, UnicodeString& name) { if (tzID.isEmpty() || tzID.startsWith(gEtcPrefix, gEtcPrefixLen) || tzID.startsWith(gSystemVPrefix, gSystemVPrefixLen) || tzID.indexOf(gRiyadh8, gRiyadh8Len, 0) > 0) { name.setToBogus(); return name; } int32_t sep = tzID.lastIndexOf((UChar)0x2F /* '/' */); if (sep > 0 && sep + 1 < tzID.length()) { name.setTo(tzID, sep + 1); name.findAndReplace(UnicodeString((UChar)0x5f /* _ */), UnicodeString((UChar)0x20 /* space */)); } else { name.setToBogus(); } return name; }
/** * This method gets called when a function is found. * * @param const UnicodeString& namespace the fully qualified namespace of the function that was found * @param const UnicodeString& functionName the name of the method that was found * @param const UnicodeString& signature string containing method parameters. String is normalized, meaning that * any extra white space is removed, and every token is separated by one space only. ie. for the code * "public function doWork( $item1, $item2 ) " the signature will be "($item1, $item2)" * @param const UnicodeString& returnType the function's return type, as dictated by the PHPDoc comment * @param const UnicodeString& comment PHPDoc attached to the class * @param lineNumber the line number (1-based) that the function was found in */ virtual void FunctionFound(const UnicodeString& namespaceName, const UnicodeString& functionName, const UnicodeString& signature, const UnicodeString& returnType, const UnicodeString& comment, const int lineNumber) { UFILE* ufout = u_finit(stdout, NULL, NULL); if (returnType.isEmpty()) { u_fprintf(ufout, "Function Found: %.*S in namespace %.*S on line %d. Function Did not have @return in PHPDoc comment\n", functionName.length(), functionName.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber); } else { u_fprintf(ufout, "Function Found: %.*S in namespace %.*S on line %d and it returns %.*S\n", functionName.length(), functionName.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber, returnType.length(), returnType.getBuffer()); } u_fclose(ufout); }
/* This method gets called when a class method is found. * * @param const UnicodeString& namespace the fully qualified namespace of the class that was found * @param const UnicodeString& className the name of the class that was found * @param const UnicodeString& methodName the name of the method that was found * @param const UnicodeString& signature string containing method parameters. String is normalized, meaning that * any extra white space is removed, and every token is separated by one space only. ie. for the code * "public function doWork( $item1, $item2 ) " the signature will be "($item1, $item2)" * @param const UnicodeString& returnType the method's return type, as dictated by the PHPDoc comment * @param const UnicodeString& comment PHPDoc attached to the class * @param visibility the visibility token attached to the method: PUBLIC, PROTECTED, or PRIVATE * @param isStatic true if the method is static * @param lineNumber the line number (1-based) that the method was found in */ virtual void MethodFound(const UnicodeString& namespaceName, const UnicodeString& className, const UnicodeString& methodName, const UnicodeString& signature, const UnicodeString& returnType, const UnicodeString& comment, pelet::TokenClass::TokenIds visibility, bool isStatic, const int lineNumber) { UFILE* ufout = u_finit(stdout, NULL, NULL); if (returnType.isEmpty()) { u_fprintf(ufout, "Method Found: %.*S in class %.*S in namespace %.*S on line %d. Method did not have @return in PHPDoc comment\n", methodName.length(), methodName.getBuffer(), className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber); } else { u_fprintf(ufout, "Method Found: %.*S in class %.*S in namespace %.*S on line %d and returns %.*S\n", methodName.length(), methodName.getBuffer(), className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber, returnType.length(), returnType.getBuffer()); } u_fclose(ufout); }
/** * Override this method to perform any custom logic when a class property is found. * * @param const UnicodeString& namespace the fully qualified namespace of the class that was found * @param const UnicodeString& className the name of the class that was found * @param const UnicodeString& propertyName the name of the property that was found * @param const UnicodeString& propertyType the property's type, as dictated by the PHPDoc comment * @param const UnicodeString& comment PHPDoc attached to the property * @param visibility the visibility token attached to the property: PUBLIC, PROTECTED, or PRIVATE * @param bool isConst true if property is a constant * @param isStatic true if the property is static * @param lineNumber the line number (1-based) that the property was found in */ virtual void PropertyFound(const UnicodeString& namespaceName, const UnicodeString& className, const UnicodeString& propertyName, const UnicodeString& propertyType, const UnicodeString& comment, pelet::TokenClass::TokenIds visibility, bool isConst, bool isStatic, const int lineNumber) { UFILE* ufout = u_finit(stdout, NULL, NULL); if (propertyType.isEmpty()) { u_fprintf(ufout, "Property Found: %.*S in class %.*S in namespace %.*S on line %d. Did not have @return in PHPDoc comment\n", propertyName.length(), propertyName.getBuffer(), className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber); } else { u_fprintf(ufout, "Property Found: %.*S in class %.*S in namespace %.*S on line %d and is of type %.*S\n", propertyName.length(), propertyName.getBuffer(), className.length(), className.getBuffer(), namespaceName.length(), namespaceName.getBuffer(), lineNumber, propertyType.length(), propertyType.getBuffer()); } u_fclose(ufout); }
std::vector<t4p::PhpTagClass> t4p::TagCacheClass::GetTagsAtPosition( const wxString& fileName, const UnicodeString& code, int posToCheck, const std::vector<wxFileName>& sourceDirs, t4p::PhpModuleClass& phpModule, wxString& status) { std::vector<t4p::PhpTagClass> matches; pelet::LexicalAnalyzerClass lexer; pelet::ParserClass parser; t4p::ScopeFinderClass scopeFinder; pelet::ScopeClass variableScope; pelet::VariableClass parsedVariable(variableScope); lexer.SetVersion(phpModule.Environment.Php.Version); parser.SetVersion(phpModule.Environment.Php.Version); scopeFinder.SetVersion(phpModule.Environment.Php.Version); UnicodeString codeUntilPos(code, 0, posToCheck); UnicodeString lastExpression = lexer.LastExpression(codeUntilPos); UnicodeString resourceName; bool doDuckTyping = true; if (!lastExpression.isEmpty()) { scopeFinder.GetScopeString(codeUntilPos, posToCheck, variableScope); if (lastExpression.indexOf(UNICODE_STRING_SIMPLE("\\")) > 0 && variableScope.ClassName.isEmpty() && variableScope.MethodName.isEmpty()) { // the expression is a namespace name outside a class or method. this is // most likely a namespace in the "use" statement // namespace in a use statement is always fully qualified, even if it does // not begin with a backslash lastExpression = UNICODE_STRING_SIMPLE("\\") + lastExpression; } parser.ParseExpression(lastExpression, parsedVariable); t4p::SymbolTableMatchErrorClass error; ResourceMatches(fileName, parsedVariable, variableScope, sourceDirs, matches, doDuckTyping, true, error); if (matches.empty()) { HandleAutoCompletionPhpStatus(error, lastExpression, parsedVariable, variableScope, matches, status); } } return matches; }
void RuleBasedNumberFormat::setDefaultRuleSet(const UnicodeString& ruleSetName, UErrorCode& status) { if (U_SUCCESS(status)) { if (ruleSetName.isEmpty()) { if (localizations) { UnicodeString name(TRUE, localizations->getRuleSetName(0), -1); defaultRuleSet = findRuleSet(name, status); } else { initDefaultRuleSet(); } } else if (ruleSetName.startsWith(UNICODE_STRING_SIMPLE("%%"))) { status = U_ILLEGAL_ARGUMENT_ERROR; } else { NFRuleSet* result = findRuleSet(ruleSetName, status); if (result != NULL) { defaultRuleSet = result; } } } }
AffixPatternMatcher AffixPatternMatcher::fromAffixPattern(const UnicodeString& affixPattern, AffixTokenMatcherWarehouse& tokenWarehouse, parse_flags_t parseFlags, bool* success, UErrorCode& status) { if (affixPattern.isEmpty()) { *success = false; return {}; } *success = true; IgnorablesMatcher* ignorables; if (0 != (parseFlags & PARSE_FLAG_EXACT_AFFIX)) { ignorables = nullptr; } else { ignorables = &tokenWarehouse.ignorables(); } AffixPatternMatcherBuilder builder(affixPattern, tokenWarehouse, ignorables); AffixUtils::iterateWithConsumer(affixPattern, builder, status); return builder.build(); }
/* * This method updates the cache and must be called with a lock, * except initializer. */ void TZGNCore::loadStrings(const UnicodeString& tzCanonicalID) { // load the generic location name getGenericLocationName(tzCanonicalID); // partial location names UErrorCode status = U_ZERO_ERROR; const UnicodeString *mzID; UnicodeString goldenID; UnicodeString mzGenName; UTimeZoneNameType genNonLocTypes[] = { UTZNM_LONG_GENERIC, UTZNM_SHORT_GENERIC, UTZNM_UNKNOWN /*terminator*/ }; StringEnumeration *mzIDs = fTimeZoneNames->getAvailableMetaZoneIDs(tzCanonicalID, status); while ((mzID = mzIDs->snext(status))) { if (U_FAILURE(status)) { break; } // if this time zone is not the golden zone of the meta zone, // partial location name (such as "PT (Los Angeles)") might be // available. fTimeZoneNames->getReferenceZoneID(*mzID, fTargetRegion, goldenID); if (tzCanonicalID != goldenID) { for (int32_t i = 0; genNonLocTypes[i] != UTZNM_UNKNOWN; i++) { fTimeZoneNames->getMetaZoneDisplayName(*mzID, genNonLocTypes[i], mzGenName); if (!mzGenName.isEmpty()) { // getPartialLocationName formats a name and put it into the trie getPartialLocationName(tzCanonicalID, *mzID, (genNonLocTypes[i] == UTZNM_LONG_GENERIC), mzGenName); } } } } if (mzIDs != NULL) { delete mzIDs; } }
Transliterator* TransliteratorRegistry::reget(const UnicodeString& ID, TransliteratorParser& parser, TransliteratorAlias*& aliasReturn, UErrorCode& status) { U_ASSERT(aliasReturn == NULL); TransliteratorEntry *entry = find(ID); if (entry == 0) { // We get to this point if there are two threads, one of which // is instantiating an ID, and another of which is removing // the same ID from the registry, and the timing is just right. return 0; } // The usage model for the caller is that they will first call // reg->get() inside the mutex, they'll get back an alias, they call // alias->isRuleBased(), and if they get TRUE, they call alias->parse() // outside the mutex, then reg->reget() inside the mutex again. A real // mess, but it gets things working for ICU 3.0. [alan]. // Note: It's possible that in between the caller calling // alias->parse() and reg->reget(), that another thread will have // called reg->reget(), and the entry will already have been fixed up. // We have to detect this so we don't stomp over existing entry // data members and potentially leak memory (u.data and compoundFilter). if (entry->entryType == TransliteratorEntry::RULES_FORWARD || entry->entryType == TransliteratorEntry::RULES_REVERSE || entry->entryType == TransliteratorEntry::LOCALE_RULES) { if (parser.idBlockVector.isEmpty() && parser.dataVector.isEmpty()) { entry->u.data = 0; entry->entryType = TransliteratorEntry::ALIAS; entry->stringArg = UNICODE_STRING_SIMPLE("Any-NULL"); } else if (parser.idBlockVector.isEmpty() && parser.dataVector.size() == 1) { entry->u.data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0); entry->entryType = TransliteratorEntry::RBT_DATA; } else if (parser.idBlockVector.size() == 1 && parser.dataVector.isEmpty()) { entry->stringArg = *(UnicodeString*)(parser.idBlockVector.elementAt(0)); entry->compoundFilter = parser.orphanCompoundFilter(); entry->entryType = TransliteratorEntry::ALIAS; } else { entry->entryType = TransliteratorEntry::COMPOUND_RBT; entry->compoundFilter = parser.orphanCompoundFilter(); entry->u.dataVector = new UVector(status); entry->stringArg.remove(); int32_t limit = parser.idBlockVector.size(); if (parser.dataVector.size() > limit) limit = parser.dataVector.size(); for (int32_t i = 0; i < limit; i++) { if (i < parser.idBlockVector.size()) { UnicodeString* idBlock = (UnicodeString*)parser.idBlockVector.elementAt(i); if (!idBlock->isEmpty()) entry->stringArg += *idBlock; } if (!parser.dataVector.isEmpty()) { TransliterationRuleData* data = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0); entry->u.dataVector->addElement(data, status); entry->stringArg += (UChar)0xffff; // use U+FFFF to mark position of RBTs in ID block } } } } Transliterator *t = instantiateEntry(ID, entry, aliasReturn, status); return t; }
Transliterator* TransliteratorAlias::create(UParseError& pe, UErrorCode& ec) { if (U_FAILURE(ec)) { return 0; } Transliterator *t = NULL; switch (type) { case SIMPLE: t = Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec); if(U_FAILURE(ec)){ return 0; } if (compoundFilter != 0) t->adoptFilter((UnicodeSet*)compoundFilter->clone()); break; case COMPOUND: { // the total number of transliterators in the compound is the total number of anonymous transliterators // plus the total number of ID blocks-- we start by assuming the list begins and ends with an ID // block and that each pair anonymous transliterators has an ID block between them. Then we go back // to see whether there really are ID blocks at the beginning and end (by looking for U+FFFF, which // marks the position where an anonymous transliterator goes) and adjust accordingly int32_t anonymousRBTs = transes->size(); int32_t transCount = anonymousRBTs * 2 + 1; if (!aliasesOrRules.isEmpty() && aliasesOrRules[0] == (UChar)(0xffff)) --transCount; if (aliasesOrRules.length() >= 2 && aliasesOrRules[aliasesOrRules.length() - 1] == (UChar)(0xffff)) --transCount; UnicodeString noIDBlock((UChar)(0xffff)); noIDBlock += ((UChar)(0xffff)); int32_t pos = aliasesOrRules.indexOf(noIDBlock); while (pos >= 0) { --transCount; pos = aliasesOrRules.indexOf(noIDBlock, pos + 1); } UVector transliterators(ec); UnicodeString idBlock; int32_t blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff)); while (blockSeparatorPos >= 0) { aliasesOrRules.extract(0, blockSeparatorPos, idBlock); aliasesOrRules.remove(0, blockSeparatorPos + 1); if (!idBlock.isEmpty()) transliterators.addElement(Transliterator::createInstance(idBlock, UTRANS_FORWARD, pe, ec), ec); if (!transes->isEmpty()) transliterators.addElement(transes->orphanElementAt(0), ec); blockSeparatorPos = aliasesOrRules.indexOf((UChar)(0xffff)); } if (!aliasesOrRules.isEmpty()) transliterators.addElement(Transliterator::createInstance(aliasesOrRules, UTRANS_FORWARD, pe, ec), ec); while (!transes->isEmpty()) transliterators.addElement(transes->orphanElementAt(0), ec); if (U_SUCCESS(ec)) { t = new CompoundTransliterator(ID, transliterators, (compoundFilter ? (UnicodeSet*)(compoundFilter->clone()) : 0), anonymousRBTs, pe, ec); if (t == 0) { ec = U_MEMORY_ALLOCATION_ERROR; return 0; } } else { for (int32_t i = 0; i < transliterators.size(); i++) delete (Transliterator*)(transliterators.elementAt(i)); } } break; case RULES: U_ASSERT(FALSE); // don't call create() if isRuleBased() returns TRUE! break; } return t; }
UnicodeString& LocaleDisplayNamesImpl::localeDisplayName(const Locale& locale, UnicodeString& result) const { if (locale.isBogus()) { result.setToBogus(); return result; } UnicodeString resultName; const char* lang = locale.getLanguage(); if (uprv_strlen(lang) == 0) { lang = "root"; } const char* script = locale.getScript(); const char* country = locale.getCountry(); const char* variant = locale.getVariant(); UBool hasScript = uprv_strlen(script) > 0; UBool hasCountry = uprv_strlen(country) > 0; UBool hasVariant = uprv_strlen(variant) > 0; if (dialectHandling == ULDN_DIALECT_NAMES) { char buffer[ULOC_FULLNAME_CAPACITY]; do { // loop construct is so we can break early out of search if (hasScript && hasCountry) { ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0); localeIdName(buffer, resultName); if (!resultName.isBogus()) { hasScript = FALSE; hasCountry = FALSE; break; } } if (hasScript) { ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0); localeIdName(buffer, resultName); if (!resultName.isBogus()) { hasScript = FALSE; break; } } if (hasCountry) { ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0); localeIdName(buffer, resultName); if (!resultName.isBogus()) { hasCountry = FALSE; break; } } } while (FALSE); } if (resultName.isBogus() || resultName.isEmpty()) { localeIdName(lang, resultName); } UnicodeString resultRemainder; UnicodeString temp; UErrorCode status = U_ZERO_ERROR; if (hasScript) { resultRemainder.append(scriptDisplayName(script, temp, TRUE)); } if (hasCountry) { appendWithSep(resultRemainder, regionDisplayName(country, temp, TRUE)); } if (hasVariant) { appendWithSep(resultRemainder, variantDisplayName(variant, temp, TRUE)); } resultRemainder.findAndReplace(formatOpenParen, formatReplaceOpenParen); resultRemainder.findAndReplace(formatCloseParen, formatReplaceCloseParen); LocalPointer<StringEnumeration> e(locale.createKeywords(status)); if (e.isValid() && U_SUCCESS(status)) { UnicodeString temp2; char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY const char* key; while ((key = e->next((int32_t *)0, status)) != NULL) { locale.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status); if (U_FAILURE(status)) { return result; } keyDisplayName(key, temp, TRUE); temp.findAndReplace(formatOpenParen, formatReplaceOpenParen); temp.findAndReplace(formatCloseParen, formatReplaceCloseParen); keyValueDisplayName(key, value, temp2, TRUE); temp2.findAndReplace(formatOpenParen, formatReplaceOpenParen); temp2.findAndReplace(formatCloseParen, formatReplaceCloseParen); if (temp2 != UnicodeString(value, -1, US_INV)) { appendWithSep(resultRemainder, temp2); } else if (temp != UnicodeString(key, -1, US_INV)) { UnicodeString temp3; keyTypeFormat.format(temp, temp2, temp3, status); appendWithSep(resultRemainder, temp3); } else { appendWithSep(resultRemainder, temp) .append((UChar)0x3d /* = */) .append(temp2); } } } if (!resultRemainder.isEmpty()) { format.format(resultName, resultRemainder, result.remove(), status); return adjustForUsageAndContext(kCapContextUsageLanguage, result); } result = resultName; return adjustForUsageAndContext(kCapContextUsageLanguage, result); }
int32_t PluralFormat::findSubMessage(const MessagePattern& pattern, int32_t partIndex, const PluralSelector& selector, void *context, double number, UErrorCode& ec) { if (U_FAILURE(ec)) { return 0; } int32_t count=pattern.countParts(); double offset; const MessagePattern::Part* part=&pattern.getPart(partIndex); if (MessagePattern::Part::hasNumericValue(part->getType())) { offset=pattern.getNumericValue(*part); ++partIndex; } else { offset=0; } // The keyword is empty until we need to match against a non-explicit, not-"other" value. // Then we get the keyword from the selector. // (In other words, we never call the selector if we match against an explicit value, // or if the only non-explicit keyword is "other".) UnicodeString keyword; UnicodeString other(FALSE, OTHER_STRING, 5); // When we find a match, we set msgStart>0 and also set this boolean to true // to avoid matching the keyword again (duplicates are allowed) // while we continue to look for an explicit-value match. UBool haveKeywordMatch=FALSE; // msgStart is 0 until we find any appropriate sub-message. // We remember the first "other" sub-message if we have not seen any // appropriate sub-message before. // We remember the first matching-keyword sub-message if we have not seen // one of those before. // (The parser allows [does not check for] duplicate keywords. // We just have to make sure to take the first one.) // We avoid matching the keyword twice by also setting haveKeywordMatch=true // at the first keyword match. // We keep going until we find an explicit-value match or reach the end of the plural style. int32_t msgStart=0; // Iterate over (ARG_SELECTOR [ARG_INT|ARG_DOUBLE] message) tuples // until ARG_LIMIT or end of plural-only pattern. do { part=&pattern.getPart(partIndex++); const UMessagePatternPartType type = part->getType(); if(type==UMSGPAT_PART_TYPE_ARG_LIMIT) { break; } U_ASSERT (type==UMSGPAT_PART_TYPE_ARG_SELECTOR); // part is an ARG_SELECTOR followed by an optional explicit value, and then a message if(MessagePattern::Part::hasNumericValue(pattern.getPartType(partIndex))) { // explicit value like "=2" part=&pattern.getPart(partIndex++); if(number==pattern.getNumericValue(*part)) { // matches explicit value return partIndex; } } else if(!haveKeywordMatch) { // plural keyword like "few" or "other" // Compare "other" first and call the selector if this is not "other". if(pattern.partSubstringMatches(*part, other)) { if(msgStart==0) { msgStart=partIndex; if(0 == keyword.compare(other)) { // This is the first "other" sub-message, // and the selected keyword is also "other". // Do not match "other" again. haveKeywordMatch=TRUE; } } } else { if(keyword.isEmpty()) { keyword=selector.select(context, number-offset, ec); if(msgStart!=0 && (0 == keyword.compare(other))) { // We have already seen an "other" sub-message. // Do not match "other" again. haveKeywordMatch=TRUE; // Skip keyword matching but do getLimitPartIndex(). } } if(!haveKeywordMatch && pattern.partSubstringMatches(*part, keyword)) { // keyword matches msgStart=partIndex; // Do not match this keyword again. haveKeywordMatch=TRUE; } } } partIndex=pattern.getLimitPartIndex(partIndex); } while(++partIndex<count); return msgStart; }
/* * This method updates the cache and must be called with a lock */ const UChar* TZGNCore::getGenericLocationName(const UnicodeString& tzCanonicalID) { U_ASSERT(!tzCanonicalID.isEmpty()); if (tzCanonicalID.length() > ZID_KEY_MAX) { return NULL; } UErrorCode status = U_ZERO_ERROR; UChar tzIDKey[ZID_KEY_MAX + 1]; int32_t tzIDKeyLen = tzCanonicalID.extract(tzIDKey, ZID_KEY_MAX + 1, status); U_ASSERT(status == U_ZERO_ERROR); // already checked length above tzIDKey[tzIDKeyLen] = 0; const UChar *locname = (const UChar *)uhash_get(fLocationNamesMap, tzIDKey); if (locname != NULL) { // gEmpty indicate the name is not available if (locname == gEmpty) { return NULL; } return locname; } // Construct location name UnicodeString name; UnicodeString usCountryCode; UBool isPrimary = FALSE; ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode, &isPrimary); if (!usCountryCode.isEmpty()) { if (isPrimary) { // If this is the primary zone in the country, use the country name. char countryCode[ULOC_COUNTRY_CAPACITY]; U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); countryCode[ccLen] = 0; UnicodeString country; fLocaleDisplayNames->regionDisplayName(countryCode, country); fRegionFormat.format(country, name, status); } else { // If this is not the primary zone in the country, // use the exemplar city name. // getExemplarLocationName should retur non-empty string // if the time zone is associated with a region UnicodeString city; fTimeZoneNames->getExemplarLocationName(tzCanonicalID, city); fRegionFormat.format(city, name, status); } if (U_FAILURE(status)) { return NULL; } } locname = name.isEmpty() ? NULL : fStringPool.get(name, status); if (U_SUCCESS(status)) { // Cache the result const UChar* cacheID = ZoneMeta::findTimeZoneID(tzCanonicalID); U_ASSERT(cacheID != NULL); if (locname == NULL) { // gEmpty to indicate - no location name available uhash_put(fLocationNamesMap, (void *)cacheID, (void *)gEmpty, &status); } else { uhash_put(fLocationNamesMap, (void *)cacheID, (void *)locname, &status); if (U_FAILURE(status)) { locname = NULL; } else { // put the name info into the trie GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); if (nameinfo != NULL) { nameinfo->type = UTZGNM_LOCATION; nameinfo->tzID = cacheID; fGNamesTrie.put(locname, nameinfo, status); } } } } return locname; }
/* * This method updates the cache and must be called with a lock */ const UChar* TZGNCore::getPartialLocationName(const UnicodeString& tzCanonicalID, const UnicodeString& mzID, UBool isLong, const UnicodeString& mzDisplayName) { U_ASSERT(!tzCanonicalID.isEmpty()); U_ASSERT(!mzID.isEmpty()); U_ASSERT(!mzDisplayName.isEmpty()); PartialLocationKey key; key.tzID = ZoneMeta::findTimeZoneID(tzCanonicalID); key.mzID = ZoneMeta::findMetaZoneID(mzID); key.isLong = isLong; U_ASSERT(key.tzID != NULL && key.mzID != NULL); const UChar* uplname = (const UChar*)uhash_get(fPartialLocationNamesMap, (void *)&key); if (uplname != NULL) { return uplname; } UnicodeString location; UnicodeString usCountryCode; ZoneMeta::getCanonicalCountry(tzCanonicalID, usCountryCode); if (!usCountryCode.isEmpty()) { char countryCode[ULOC_COUNTRY_CAPACITY]; U_ASSERT(usCountryCode.length() < ULOC_COUNTRY_CAPACITY); int32_t ccLen = usCountryCode.extract(0, usCountryCode.length(), countryCode, sizeof(countryCode), US_INV); countryCode[ccLen] = 0; UnicodeString regionalGolden; fTimeZoneNames->getReferenceZoneID(mzID, countryCode, regionalGolden); if (tzCanonicalID == regionalGolden) { // Use country name fLocaleDisplayNames->regionDisplayName(countryCode, location); } else { // Otherwise, use exemplar city name fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); } } else { fTimeZoneNames->getExemplarLocationName(tzCanonicalID, location); if (location.isEmpty()) { // This could happen when the time zone is not associated with a country, // and its ID is not hierarchical, for example, CST6CDT. // We use the canonical ID itself as the location for this case. location.setTo(tzCanonicalID); } } UErrorCode status = U_ZERO_ERROR; UnicodeString name; fFallbackFormat.format(location, mzDisplayName, name, status); if (U_FAILURE(status)) { return NULL; } uplname = fStringPool.get(name, status); if (U_SUCCESS(status)) { // Add the name to cache PartialLocationKey* cacheKey = (PartialLocationKey *)uprv_malloc(sizeof(PartialLocationKey)); if (cacheKey != NULL) { cacheKey->tzID = key.tzID; cacheKey->mzID = key.mzID; cacheKey->isLong = key.isLong; uhash_put(fPartialLocationNamesMap, (void *)cacheKey, (void *)uplname, &status); if (U_FAILURE(status)) { uprv_free(cacheKey); } else { // put the name to the local trie as well GNameInfo *nameinfo = (ZNameInfo *)uprv_malloc(sizeof(GNameInfo)); if (nameinfo != NULL) { nameinfo->type = isLong ? UTZGNM_LONG : UTZGNM_SHORT; nameinfo->tzID = key.tzID; fGNamesTrie.put(uplname, nameinfo, status); } } } } return uplname; }