/**
* 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;
}
