void MacOSUnicodeConverter::upperCase(XMLCh* const toUpperCase)
{
#if TARGET_API_MAC_CARBON
// If we're targeting carbon, use the CFString conversion to uppercase
int len = XMLString::stringLen(toUpperCase);
CFMutableStringRef cfString = CFStringCreateMutableWithExternalCharactersNoCopy(
kCFAllocatorDefault,
(UniChar*)toUpperCase,
len, // length
len, // capacity
kCFAllocatorNull);
CFStringUppercase(cfString, NULL);
CFRelease(cfString);
#elif (__GNUC__ >= 3 && _GLIBCPP_USE_WCHAR_T)
// Use this if there's a reasonable c library available.
// Metrowerks does this reasonably
wchar_t c;
for (XMLCh* p = (XMLCh*)toUpperCase; ((c = *p) != 0); )
*p++ = std::towupper(c);
#else
#error Sorry, no support for upperCase
#endif
}
CF_EXPORT CFStringRef CFBundleCopyLocalizedStringForLocalization(CFBundleRef bundle, CFStringRef key, CFStringRef value, CFStringRef tableName, CFStringRef localizationName) {
if (!key) { return (value ? (CFStringRef)CFRetain(value) : (CFStringRef)CFRetain(CFSTR(""))); }
// Make sure to check the mixed localizations key early -- if the main bundle has not yet been cached, then we need to create the cache of the Info.plist before we start asking for resources (11172381)
(void)CFBundleAllowMixedLocalizations();
if (!tableName || CFEqual(tableName, CFSTR(""))) tableName = _CFBundleDefaultStringTableName;
CFStringRef result = _copyStringFromTable(bundle, tableName, key, localizationName);
if (!result) {
if (!value) {
result = (CFStringRef)CFRetain(key);
} else if (CFEqual(value, CFSTR(""))) {
result = (CFStringRef)CFRetain(key);
} else {
result = (CFStringRef)CFRetain(value);
}
static Boolean capitalize = false;
if (capitalize) {
CFMutableStringRef capitalizedResult = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, result);
os_log_error(_CFBundleLocalizedStringLogger(), "ERROR: %@ not found in table %@ of bundle %@", key, tableName, bundle);
CFStringUppercase(capitalizedResult, NULL);
CFRelease(result);
result = capitalizedResult;
}
}
os_log_debug(_CFBundleLocalizedStringLogger(), "Bundle: %{private}@, key: %{public}@, value: %{public}@, table: %{public}@, localizationName: %{public}@, result: %{public}@", bundle, key, value, tableName, localizationName, result);
return result;
}
CFStringRef uppercase(CFStringRef s)
{
CFLocaleRef localeRef = CFLocaleCopyCurrent();
CFMutableStringRef ms = CFStringCreateMutableCopy(NULL, 0, s);
CFStringUppercase(ms, localeRef);
CFRelease(localeRef);
return ms;
}
rktio_char16_t *rktio_recase_utf16(rktio_t *rktio, rktio_bool_t to_up, rktio_char16_t *s1, intptr_t l1, intptr_t *olen)
{
#ifdef MACOS_UNICODE_SUPPORT
CFMutableStringRef mstr;
CFStringRef str;
CFRange rng;
rktio_char16_t *result;
intptr_t len;
str = CFStringCreateWithBytes(NULL, (unsigned char *)s1, (l1 * sizeof(rktio_char16_t)), kCFStringEncodingUnicode, FALSE);
mstr = CFStringCreateMutableCopy(NULL, 0, str);
CFRelease(str);
if (to_up)
CFStringUppercase(mstr, NULL);
else
CFStringLowercase(mstr, NULL);
len = CFStringGetLength(mstr);
result = malloc((len + 1) * sizeof(rktio_char16_t));
rng = CFRangeMake(0, len);
CFStringGetCharacters(mstr, rng, (UniChar *)result);
CFRelease(mstr);
result[len] = 0;
if (olen)
*olen = len;
return result;
#elif defined(RKTIO_SYSTEM_WINDOWS)
rktio_char16_t *result;
result = malloc((l1 + 1) * sizeof(rktio_char16_t));
memcpy(result, s1, l1 * sizeof(rktio_char16_t));
result[l1] = 0;
if (to_up)
CharUpperBuffW((wchar_t *)result, l1);
else
CharLowerBuffW((wchar_t *)result, l1);
if (olen)
*olen = l1;
return result;
#else
return NULL;
#endif
}
Tcl_UniChar Tcl_UniCharToUpper(Tcl_UniChar c)
{
if (c < 0x7f)
return toupper(c);
CFMutableStringRef str = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorDefault,&c, 1,0, kCFAllocatorNull);
CFStringUppercase(str,NULL);
Tcl_UniChar retval = c;
if (CFStringGetLength(str)) { // make sure one exists
retval = CFStringGetCharacterAtIndex(str, 0);
}
CFRelease(str);
return retval;
}
/*++
Function:
PAL_towupper
See MSDN
--*/
wchar_16
__cdecl
PAL_towupper( wchar_16 c )
{
#if HAVE_COREFOUNDATION
PERF_ENTRY(towupper);
ENTRY("towupper (c=%d)\n", c);
if (!PAL_iswupper(c))
{
CFMutableStringRef cfString = CFStringCreateMutable(
kCFAllocatorDefault, 1);
if (cfString != NULL)
{
CFStringAppendCharacters(cfString, (const UniChar*)&c, 1);
CFStringUppercase(cfString, NULL);
c = CFStringGetCharacterAtIndex(cfString, 0);
CFRelease(cfString);
}
}
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
#else /* HAVE_COREFOUNDATION */
UnicodeDataRec dataRec;
PERF_ENTRY(towupper);
ENTRY("towupper (c=%d)\n", c);
if (!GetUnicodeData(c, &dataRec))
{
TRACE( "Unable to retrieve unicode data for the character %c.\n", c );
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
}
if ( (dataRec.C1_TYPE_FLAGS & C1_UPPER) || (dataRec.nOpposingCase == 0 ))
{
LOGEXIT("towupper returns int %d\n", c );
PERF_EXIT(towupper);
return c;
}
else
{
LOGEXIT("towupper returns int %d\n", dataRec.nOpposingCase );
PERF_EXIT(towupper);
return dataRec.nOpposingCase;
}
#endif /* HAVE_COREFOUNDATION */
}
char* MSStringMgr::upperUTF8(char* text, const unsigned int maxlen) {
if (isUtf8(text)) {
const int max = (maxlen>0) ? maxlen : strlen(text);
CFStringRef cfString;
CFMutableStringRef mstr;
cfString = CFStringCreateWithBytes (NULL, (UInt8*)text, max, kCFStringEncodingUTF8, false);
if(!cfString) return text;
mstr = CFStringCreateMutableCopy(NULL, 0, cfString);
CFStringUppercase(mstr, NULL);
CFStringGetBytes (
mstr,
CFRangeMake(0, CFStringGetLength(mstr)),
kCFStringEncodingUTF8,
0,
false,
(UInt8*)text,
max,
NULL
);
CFRelease(cfString);
CFRelease(mstr);
return text;
} else {
char* ret = text;
while (*text) {
*text = toupper(*text);
text++;
}
return ret;
}
return text;
}
int SMBCheckForAlreadyMountedShare(SMBHANDLE inConnection,
CFStringRef shareRef, CFMutableDictionaryRef mdictRef,
struct statfs *fs, int fs_cnt)
{
void * hContext;
NTSTATUS status;
CFMutableStringRef upperStringRef;
char ShareName[SMB_MAXSHARENAMELEN + 1];
memset(ShareName, 0, sizeof(ShareName));
status = SMBServerContext(inConnection, &hContext);
if (!NT_SUCCESS(status)) {
return EBADF;
}
upperStringRef = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, shareRef);
if (upperStringRef == NULL) {
return ENOMEM;
}
CFStringUppercase(upperStringRef, NULL);
CFStringGetCString(upperStringRef, ShareName, SMB_MAXSHARENAMELEN + 1, kCFStringEncodingUTF8);
CFRelease(upperStringRef);
return already_mounted(hContext, ShareName, fs, fs_cnt, mdictRef, 0);
}
void stringManipulation(void) {
CFMutableStringRef strChange;
CFStringRef strOuter, find, replace, find2, replace2, find3, replace3, bigger, smaller, result;
CFComparisonResult comp;
CFLocaleRef curLocale;
Boolean isHyphenationSupported = false;
show(CFSTR("------------------String Manipulations---------------"));
// Create a simple immutable string from a Pascal string and convert it to Unicode
strOuter = CFStringCreateWithCString(NULL, "Hello Cruel World", kCFStringEncodingASCII);
strChange = CFStringCreateMutableCopy(NULL, CFStringGetLength(strOuter), strOuter);
find = CFStringCreateWithCString(NULL, "Cruel", kCFStringEncodingASCII);
replace = CFStringCreateWithCString(NULL, "Cool", kCFStringEncodingASCII);
find2 = CFStringCreateWithCString(NULL, "Keep", kCFStringEncodingASCII);
replace2 = CFStringCreateWithCString(NULL, "Be", kCFStringEncodingASCII);
find3 = CFStringCreateWithCString(NULL, "Change.", kCFStringEncodingASCII);
replace3 = CFStringCreateWithCString(NULL, "Ball.", kCFStringEncodingASCII);
bigger = CFStringCreateWithCString(NULL, "version 2.5", kCFStringEncodingASCII);
smaller = CFStringCreateWithCString(NULL, "version 2.0", kCFStringEncodingASCII);
show(CFSTR("String Outer : %@"), strOuter);
show(CFSTR("String Find : %@"), find);
show(CFSTR("String Replace : %@"), replace);
CFStringFindAndReplace(strChange, find, replace, CFRangeMake(0, CFStringGetLength(strChange)), 0);
show(CFSTR("Replaced : %@"), strChange);
CFStringAppendCString(strChange, "! Keep the change.", kCFStringEncodingASCII);
show(CFSTR("Appended : %@"), strChange);
curLocale = CFLocaleCopyCurrent ();
isHyphenationSupported = CFStringIsHyphenationAvailableForLocale(curLocale);
show(CFSTR("Is Hyphenation supported for this locale? %@"), ((isHyphenationSupported) ? CFSTR ("Yes") : CFSTR("No")));
CFStringUppercase(strChange, curLocale);
show(CFSTR("Upper Cased : %@"), strChange);
CFStringLowercase(strChange, curLocale);
show(CFSTR("Lower Cased : %@"), strChange);
CFStringCapitalize(strChange, curLocale);
show(CFSTR("Capitalized : %@"), strChange);
CFStringUppercase(strChange, curLocale);
show(CFSTR("Up Cased (again) : %@"), strChange);
CFStringFindAndReplace(strChange, find2, replace2, CFRangeMake(0, CFStringGetLength(strChange)), 0);
show(CFSTR("Replaced? : %@"), strChange);
CFStringFindAndReplace(strChange, find2, replace2, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareCaseInsensitive);
show(CFSTR("Case insensitive : %@"), strChange);
CFStringCapitalize(strChange, curLocale);
show(CFSTR("Capitalized : %@"), strChange);
CFStringFindAndReplace(strChange, replace2, find2, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareAnchored);
show(CFSTR("Should Be Unchanged: %@"), strChange);
CFStringFindAndReplace(strChange, find3, replace3, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareAnchored|kCFCompareBackwards);
show(CFSTR("Should Be Changed : %@"), strChange);
show(CFSTR("Which is bigger %@ or %@?"), bigger, smaller);
comp = CFStringCompare(bigger, smaller, 0);
result = (comp == kCFCompareGreaterThan) ? bigger : smaller;
show(CFSTR("Base Compare Says : %@"), result);
comp = CFStringCompare(bigger, smaller, kCFCompareNumerically);
result = (comp == kCFCompareGreaterThan) ? bigger : smaller;
show(CFSTR("Numerical Compare : %@"), result);
CFRelease(curLocale);
CFRelease(replace);
CFRelease(find);
CFRelease(replace2);
CFRelease(find2);
CFRelease(replace3);
CFRelease(find3);
CFRelease(bigger);
CFRelease(smaller);
CFRelease(strChange);
}
static CFStringRef
copy_default_name(void)
{
CFStringRef model;
size_t n;
CFMutableStringRef str;
// get HW model name
model = _SC_hw_model(TRUE);
if (model == NULL) {
return NULL;
}
// start off with the [trunated] HW model
str = CFStringCreateMutable(NULL, 0);
CFStringAppend(str, model);
// truncate as needed
n = CFStringGetLength(str);
if (n > (NETBIOS_NAME_LEN - 1)) {
CFStringReplace(str,
CFRangeMake(NETBIOS_NAME_LEN, n - (NETBIOS_NAME_LEN - 1)),
CFSTR(""));
n = NETBIOS_NAME_LEN - 1;
}
//
// if there is room for at least one byte (two hex characters)
// of the MAC address than append that to the NetBIOS name.
//
// NETBIOS_NAME_LEN max length
// -1 the last byte is reserved
// -3 "-XX"
//
if (n < (NETBIOS_NAME_LEN - 1 - 3)) {
SCNetworkInterfaceRef interface;
interface = _SCNetworkInterfaceCreateWithBSDName(NULL, CFSTR("en0"),
kIncludeNoVirtualInterfaces);
if (interface != NULL) {
CFMutableStringRef en0_MAC;
en0_MAC = (CFMutableStringRef)SCNetworkInterfaceGetHardwareAddressString(interface);
if (en0_MAC != NULL) {
CFIndex en0_MAC_len;
// remove ":" characters from MAC address string
en0_MAC = CFStringCreateMutableCopy(NULL, 0, en0_MAC);
CFStringFindAndReplace(en0_MAC,
CFSTR(":"),
CFSTR(""),
CFRangeMake(0, CFStringGetLength(en0_MAC)),
0);
//
// compute how may bytes (characters) to append
// ... and limit that number to 6
//
// NETBIOS_NAME_LEN max length
// -1 the last byte is reserved
// -n "iMac"
// -1 "-"
//
n = ((NETBIOS_NAME_LEN - 1 - n - 1) / 2) * 2;
if (n > 6) {
n = 6;
}
// remove what we don't want
en0_MAC_len = CFStringGetLength(en0_MAC);
if (en0_MAC_len > n) {
CFStringDelete(en0_MAC, CFRangeMake(0, en0_MAC_len - n));
}
// append
CFStringAppendFormat(str, NULL, CFSTR("-%@"), en0_MAC);
CFRelease(en0_MAC);
}
CFRelease(interface);
}
}
CFStringUppercase(str, NULL);
return str;
}
CFStringRef
SMBCreateNetBIOSName(CFStringRef proposedName)
{
CFMutableStringRef composedName;
CFStringEncoding codepage;
CFIndex nconverted = 0;
CFIndex nused = 0;
uint8_t name_buffer[NetBIOS_NAME_LEN];
if (proposedName == NULL) {
return NULL;
}
codepage = getPrefsCodePage();
composedName = CFStringCreateMutableCopy(kCFAllocatorDefault,
0, proposedName);
if (!composedName) {
return NULL;
}
CFStringTrimWhitespace(composedName);
CFStringUppercase(composedName, CFLocaleGetSystem());
nconverted = CFStringGetBytes(composedName,
CFRangeMake(0,
MIN((CFIndex)sizeof(name_buffer), CFStringGetLength(composedName))),
codepage, 0 /* loss byte */, false /* no BOM */,
name_buffer, sizeof(name_buffer), &nused);
/* We expect the conversion above to always succeed, given that we
* tried to remove anything that might not convert to a code page.
*/
if (nconverted == 0) {
char buf[256];
buf[0] = '\0';
CFStringGetCString(composedName, buf, sizeof(buf), kCFStringEncodingUTF8);
SMBLogInfo("failed to compose a NetBIOS name string from '%s'",
ASL_LEVEL_DEBUG, buf);
CFRelease(composedName);
return NULL;
}
CFRelease(composedName);
/* Null terminate for the benefit of CFStringCreate. Be careful to be
* no more that 15 bytes, since the last byte is reserved for the name
* type.
*/
name_buffer[MIN(nused, (CFIndex)sizeof(name_buffer) - 1)] = '\0';
composedName = CFStringCreateMutable(kCFAllocatorDefault,
NetBIOS_NAME_LEN);
if (composedName == NULL) {
return NULL;
}
CFStringAppendCString(composedName, (const char *)name_buffer, codepage);
return composedName;
}
