| #ifndef _H_SuperString |
| #define _H_SuperString |
| |
| #include <string> |
| #include <cctype> |
| #include "string.h" |
| #include <stdarg.h> |
| #include "CFUtils.h" |
| |
| #define kCodePage_WindowsLatin1 1252 |
| #define kCFStringEncodingPercentEscapes (0xfffffffeU) |
| |
| #ifdef __WIN32__ |
| typedef std::vector<wchar_t> WCharVec; |
| #include "Files.h" |
| #else |
| #include <Carbon/Carbon.h> |
| #endif |
| |
| #if !_YAAF_ |
| #ifndef _CFTEST_ |
| #ifndef _CONSTRUCTOR_ |
| #include "StringUtils.h" |
| #endif |
| #endif |
| #endif |
| |
| /****************************************************************/ |
| void mt_vsnprintf(char *destZ, size_t sizeL, const char *formatZ, va_list &args); |
| void LogErr(const char *strZ, OSStatus err, bool crB = true, bool unixB = false); |
| void ReportErr(const SuperString& errTypeStr, OSStatus err = 0, bool unixB = false); |
| |
| /****************************************************************/ |
| |
| char * CopyFloatToC(float valF, char *bufZ, short precisionS = 2); |
| float CStringToFloat(const char *numF); |
| char* strrstr(const char* stringZ, const char* findZ); |
| const char * CopyLongToC(long valL); |
| OSType GetExtension(const char *strZ); |
| |
| CFStringRef CFStrCreateWithCurAbsTime(); |
| bool CFStringContains(CFStringRef inRef, CFStringRef findRef, bool case_sensitiveB = false); |
| CFComparisonResult CFStringCompare(CFStringRef str1, CFStringRef str2, bool case_sensitiveB = false); |
| bool CFStringEqual(CFStringRef str1, CFStringRef str2, bool case_sensitiveB = false); |
| bool CFStringLess(CFStringRef lhs, CFStringRef rhs, bool case_sensitiveB = false); |
| bool CFStringIsEmpty(CFStringRef nameRef); |
| |
| void SetDefaultEncoding(CFStringEncoding encoding); |
| bool IsDefaultEncodingSet(); |
| |
| ustring &CopyCFStringToUString( |
| CFStringRef str, |
| ustring &result, |
| CFStringEncoding encoding = kCFStringEncodingUTF8, |
| bool externalB = false); |
| |
| CFStringRef CFStringCreateWithC( |
| const char * bufZ, |
| CFStringEncoding encoding = kCFStringEncodingInvalidId); |
| |
| CFStringRef CFStringCreateWithCu( |
| const UTF8Char * bufZ, |
| CFStringEncoding encoding = kCFStringEncodingUTF8); |
| |
| std::string &CopyCFStringToStd( |
| CFStringRef str, |
| std::string &stdstr, |
| CFStringEncoding encoding = kCFStringEncodingInvalidId); |
| |
| void CFStrReplaceWith(CFMutableStringRef stringRef, CFStringRef replaceStr, CFStringRef withStr); |
| |
| extern bool g_pref_diacritic_insensitive_searchB; |
| |
| |
| /****************************************************************/ |
| typedef struct { |
| const char *replaceZ; |
| const char *withZ; |
| } SuperStringReplaceRec; |
| |
| class UniString { |
| UTF16Char i_nullChar; |
| UTF16Vec *i_charVecP; |
| |
| void UpdateNamePointer() { |
| if (i_charVecP) { |
| i_charVecP->push_back(0); |
| i_nameP = &(*i_charVecP)[0]; |
| } else { |
| i_nameP = &i_nullChar; |
| } |
| } |
| |
| public: |
| void Initialize(CFStringRef cf_name, bool forceBigEndianB = false) { |
| if (cf_name && !CFStringIsEmpty(cf_name)) { |
| ustring utf16str; |
| |
| CopyCFStringToUString(cf_name, utf16str, forceBigEndianB ? kCFStringEncodingUTF16BE : kCFStringEncodingUTF16); |
| |
| // divide by 2 |
| i_lengthL = utf16str.size() >> 1; |
| |
| if (i_charVecP == NULL) { |
| i_charVecP = new UTF16Vec(); |
| } |
| |
| UTF16Char *utf16A = (UTF16Char *)utf16str.c_str(); |
| |
| i_charVecP->assign(&utf16A[0], &utf16A[i_lengthL]); |
| // CFStringGetCharacters(cf_name, CFRangeMake(0, i_lengthL), &(*i_charVecP)[0]); |
| } else { |
| delete i_charVecP; |
| i_charVecP = NULL; |
| i_lengthL = 0; |
| } |
| |
| UpdateNamePointer(); |
| } |
| |
| #if defined(__MWERKS__) |
| typedef long UniCharCount; |
| #endif |
| |
| UniCharCount i_lengthL; |
| UniChar *i_nameP; |
| |
| UniString(const UniString &uni) : i_nameP(NULL), i_charVecP(NULL), i_nullChar(0) { |
| i_lengthL = uni.i_lengthL; |
| |
| if (i_lengthL) { |
| i_charVecP = new UTF16Vec(); |
| i_charVecP->resize(i_lengthL); |
| std::copy(&uni.i_nameP[0], &uni.i_nameP[i_lengthL], &(*i_charVecP)[0]); |
| } |
| |
| UpdateNamePointer(); |
| } |
| |
| UniString(CFStringRef cf_name, bool forceBigEndianB = false) : i_nameP(NULL), i_charVecP(NULL), i_nullChar(0) { |
| Initialize(cf_name, forceBigEndianB); |
| } |
| |
| UniString(const char *nameZ = NULL) : i_nameP(NULL), i_charVecP(NULL), i_nullChar(0), i_lengthL(0) { |
| if (nameZ) { |
| ScCFReleaser<CFStringRef> cf_name(CFStringCreateWithC(nameZ)); |
| |
| Initialize(cf_name); |
| } |
| } |
| |
| ~UniString() { |
| delete i_charVecP; |
| } |
| }; |
| |
| #if defined(__WIN32__) |
| #ifndef __MACTYPES__ |
| typedef RECT Rect; |
| typedef UInt32 OSType; |
| #endif |
| #endif |
| |
| std::string ULong_To_Hex(UInt32 valueL); |
| UInt32 Hex_To_ULong(const char *hexZ); |
| OSType CharToOSType(const char *bufZ); |
| |
| typedef std::vector<UTF32Char> UTF32CharVec; |
| typedef std::basic_string<UTF32Char, std::char_traits<UTF32Char>, std::allocator<UTF32Char> > ww_string; |
| |
| class SuperString { |
| CFStringRef i_ref; |
| mutable std::string *i_std; |
| mutable UniString *i_uni; |
| mutable ustring *i_utf8; |
| mutable ustring *i_pstr; |
| mutable ww_string *i_utf32; |
| |
| public: |
| const std::string &std() const { Update_std(); return *i_std; } |
| const CFStringRef &ref() const { return i_ref; } |
| const UniString &uni(bool forceBigEndianB = false) const { Update_uni(forceBigEndianB); return *i_uni; } |
| const ustring &utf8() const { Update_utf8(); return *i_utf8; } |
| const char * c_str() const { return std().c_str(); } |
| const char * utf8Z() const { return (const char *)utf8().c_str(); } |
| ConstStr255Param p_str() const { Update_pstr(); return i_pstr->c_str(); } |
| const ww_string& utf32() const { Update_utf32(); return *i_utf32; } |
| |
| #ifdef __WIN32__ |
| LPCWSTR w_str() const { return (LPCWSTR)uni().i_nameP; } |
| size_t w_strlen() const { return w_size(); } |
| #endif |
| |
| operator const UniString&() const { return uni(); } |
| operator const std::string&() const { return std(); } |
| //operator const ustring&() const { return utf8(); } causes all sorts of ambiguities |
| operator CFStringRef() const { return ref(); } |
| operator const UInt8*() const { return utf8().c_str(); } |
| |
| /************************************/ |
| SuperString& Truncate(bool activeB, const Rect& frameR); |
| SuperString& ssprintf(const char *formatZ0, ...); |
| SuperString& format(const char *formatZ0, ...); |
| |
| private: |
| void SetNULL() |
| { |
| i_ref = NULL; |
| i_std = NULL; |
| i_uni = NULL; |
| i_utf8 = NULL; |
| i_utf32 = NULL; |
| i_pstr = NULL; |
| } |
| |
| public: |
| #ifdef __WIN32__ |
| SuperString(const wchar_t *wcharZ); |
| |
| SuperString(const WCharVec& wcharVec) { |
| SetNULL(); |
| Set(*(UTF16Vec *)&wcharVec); |
| } |
| #endif |
| |
| SuperString(const HFSUniStr255 &str) { |
| SetNULL(); |
| |
| ScCFReleaser<CFStringRef> myRef = CFStringCreateWithCharacters( |
| kCFAllocatorDefault, |
| str.unicode, |
| str.length); |
| |
| Set(myRef); |
| } |
| |
| SuperString(const char *strZ = NULL, CFStringEncoding encoding = kCFStringEncodingInvalidId) { |
| SetNULL(); |
| Set(uc(strZ), encoding); |
| } |
| |
| SuperString(const SuperString &sstr) { |
| SetNULL(); |
| Set(sstr.ref()); |
| } |
| |
| #ifdef _KJAMS_ |
| #ifndef _KJAMSX_ |
| void Set(const CDHMSF msf, kTimeCodeType type = kTimeCode_NORMAL) { |
| char bufAC[256]; |
| |
| Set(CopyMSFToC(msf, bufAC, type)); |
| } |
| |
| SuperString(const CDHMSF msf, kTimeCodeType type = kTimeCode_NORMAL) { |
| SetNULL(); |
| Set(msf, type); |
| } |
| #endif |
| #endif |
| |
| /* |
| FAIL! |
| SuperString(const UInt16* strZ) { |
| SetNULL(); |
| |
| ScCFReleaser<CFStringRef> myRef = strZ |
| ? CFStringCreateWithC((const char *)strZ, kCFStringEncodingUnicode) : |
| (CFStringRef)CFRetainDebug(CFSTR("")); |
| |
| Set(myRef); |
| } |
| */ |
| |
| SuperString(const UInt8 *strZ) { |
| SetNULL(); |
| Set(strZ); |
| } |
| |
| SuperString(long valL) { |
| SetNULL(); |
| append(valL); |
| } |
| |
| /* |
| dam! this causes ambiguation |
| SuperString(double valF) { |
| SetNULL(); |
| append((float)valF); |
| } |
| */ |
| |
| SuperString(const ustring &str) { |
| SetNULL(); |
| Set(str.c_str()); |
| } |
| |
| SuperString(const std::string &str) { |
| SetNULL(); |
| Set(str.c_str()); |
| } |
| |
| SuperString(CFStringRef myRef, bool retainB = true) { |
| SetNULL(); |
| Set(myRef, retainB); |
| } |
| |
| void Set_CFType(CFTypeRef cfType); |
| |
| /************************************/ |
| void Set_p(ConstStr255Param strZ, CFStringEncoding encoding = kCFStringEncodingInvalidId); |
| |
| void Set(const char *strZ) { |
| ScCFReleaser<CFStringRef> myRef = CFStringCreateWithC(strZ); |
| |
| Set(myRef); |
| } |
| |
| void Set(const UInt8 *strZ, CFStringEncoding encoding = kCFStringEncodingUTF8) { |
| ScCFReleaser<CFStringRef> myRef; |
| |
| if (strZ) { |
| if (encoding == kCFStringEncodingPercentEscapes) { |
| Set(strZ, kCFStringEncodingASCII); |
| |
| UnEscape(); |
| return; |
| } else { |
| myRef.Set(CFStringCreateWithCu(strZ, encoding)); |
| } |
| } else { |
| myRef.Set((CFStringRef)CFRetainDebug(CFSTR(""))); |
| } |
| |
| Set(myRef); |
| } |
| |
| void Escape() { |
| Set(CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, ref(), NULL, NULL, kCFStringEncodingUTF8), false); |
| } |
| |
| void UnEscape() { |
| Set(CFURLCreateStringByReplacingPercentEscapes(kCFAllocatorDefault, ref(), CFSTR(""))); |
| } |
| |
| void Set(const ustring& utf8, CFStringEncoding encoding = kCFStringEncodingUTF8) { |
| Set(utf8.c_str(), encoding); |
| } |
| |
| void Set(const UTF16Vec &vec) { |
| ScCFReleaser<CFStringRef> myRef = CFStringCreateWithCharacters(kCFAllocatorDefault, &vec[0], vec.size()); |
| |
| Set(myRef); |
| } |
| |
| void assign(const UTF8Char *beginZ, const UTF8Char *endZ, CFStringEncoding encoding = kCFStringEncodingUTF8) { |
| ustring str(beginZ, endZ); |
| |
| Set(str, encoding); |
| } |
| |
| void Set(const SuperString &sstr) { |
| if (&sstr != this) { |
| Set(sstr.i_ref); |
| } |
| } |
| |
| CFStringRef Retain() const { CFRetainDebug(i_ref); return i_ref; } |
| |
| void Set(CFStringRef myRef, bool retainB = true); |
| |
| /************************************/ |
| ~SuperString() { |
| Set((CFStringRef)NULL, false); |
| } |
| |
| void Release() { |
| CFReleaseDebug(i_ref); |
| } |
| |
| /************************************/ |
| void Update_pstr() const { |
| |
| if (!i_pstr) { |
| i_pstr = new ustring; |
| i_pstr->push_back(0); |
| Update_std(); |
| i_pstr->insert(i_pstr->end(), i_std->begin(), i_std->end()); |
| (*i_pstr)[0] = i_pstr->size() - 1; |
| |
| delete i_std; |
| i_std = NULL; |
| } |
| } |
| |
| void Update_uni(bool forceBigEndianB) const { |
| if (!i_uni) { |
| i_uni = new UniString(i_ref, forceBigEndianB); |
| } |
| } |
| |
| void Update_std() const { |
| if (!i_std) { |
| i_std = new std::string; |
| CopyCFStringToStd(i_ref, *i_std); |
| } |
| } |
| |
| void Update_utf32() const; |
| void Update_utf8() const { |
| if (!i_utf8) { |
| i_utf8 = new ustring; |
| CopyCFStringToUString(i_ref, *i_utf8); |
| } |
| } |
| |
| /************************************/ |
| void clear() { Set((CFStringRef)NULL); } |
| |
| bool Contains(const SuperString& other) const { |
| return strstr(utf8Z(), other.utf8Z()) != NULL; |
| } |
| |
| // returns number of utf8 bytes (not characters) that match the start of the other string |
| size_t MatchStart(const SuperString& other, char delimiterCh = 0); |
| |
| bool StartsWith(const SuperString& other) { |
| return MatchStart(other) == other.size(); |
| } |
| |
| SuperString& ReplaceTable(SuperStringReplaceRec *recA, long sizeL); |
| SuperString& Replace(const SuperString& replaceStr, const SuperString& withStr) { |
| ScCFReleaser<CFMutableStringRef> newRef(CFStringCreateMutableCopy(NULL, 0, i_ref)); |
| |
| CFStrReplaceWith(newRef, replaceStr.ref(), withStr.ref()); |
| Set(newRef); |
| return *this; |
| } |
| |
| SuperString &UnderScoresToSpaces() { |
| return Replace("_", " "); |
| } |
| |
| // returns a new string, does not modify original |
| SuperString md5() const; |
| |
| SuperString& Scramble(); |
| SuperString& UnScramble(); |
| |
| SuperString& trim(); |
| |
| #if _KJ_MAC_ |
| void MakeRecoverable(bool old_styleB = false) { |
| ScCFReleaser<CFStringRef> sc(CFStrCreateRecoverableName(i_ref, false)); |
| |
| Set(sc); |
| } |
| |
| SuperString& Recover() { |
| ScCFReleaser<CFStringRef> sc(CFStrRecoverName(i_ref)); |
| |
| Set(sc); |
| return *this; |
| } |
| |
| SuperString& RecoverCaps(bool titleCaseB = true) { |
| Recover(); |
| InterCaps(false, titleCaseB); |
| MakeRecoverable(); |
| return *this; |
| } |
| |
| #endif |
| |
| CFDataRef CopyDataRef() { |
| return CFStringCreateExternalRepresentation( |
| kCFAllocatorDefault, i_ref, kCFStringEncodingUTF8, 0); |
| } |
| |
| void Set(CFDataRef dataRef) { |
| ScCFReleaser<CFStringRef> myRef = CFStringCreateFromExternalRepresentation( |
| kCFAllocatorDefault, dataRef, kCFStringEncodingUTF8); |
| |
| Set(myRef); |
| } |
| |
| size_t size() const { return utf8().size(); } // utf8 chars |
| size_t w_size() const { return uni().i_lengthL; } // utf16 chars |
| size_t ww_size() const { return utf32().size(); } // utf32 chars |
| |
| /* |
| ambiguous |
| |
| char operator[](size_t indexS) { |
| char ch = 0; |
| |
| if (utf8().size() > indexS) { |
| ch = utf8().c_str()[indexS]; |
| } |
| |
| return ch; |
| } |
| */ |
| |
| UTF32Char GetIndChar_ww(size_t indexL = 0) const { |
| UTF32Char ch = 0; |
| |
| if (indexL >= 0 && indexL < utf32().size()) { |
| ch = utf32()[indexL]; |
| } |
| |
| return ch; |
| } |
| |
| UTF8Char GetIndChar(size_t indexL = 0) const { |
| UTF8Char ch = 0; |
| |
| if (indexL >= 0 && indexL < utf8().size()) { |
| ch = utf8()[indexL]; |
| } |
| |
| return ch; |
| } |
| |
| UTF8Char GetIndCharR(long indexL = 0) const { |
| return GetIndChar(utf8().size() - (indexL + 1)); |
| } |
| |
| SuperString& ToUpper(); |
| SuperString& ToLower(); |
| bool IsAllCaps(); |
| SuperString& Normalize(); |
| SuperString& InterCaps(bool allow_line_breaksB = false, bool titleCaseB = true); |
| SuperString& TheToEnd(); |
| |
| SuperString& operator =(const SuperString &other) { Set(other); return *this; } |
| SuperString& operator =(const char *otherZ) { Set(otherZ); return *this; } |
| |
| bool operator<(CFStringRef other) const { |
| return CFStringLess(i_ref, other); |
| } |
| |
| bool operator>(CFStringRef other) const { |
| return CFStringLess(other, i_ref); |
| } |
| |
| bool operator ==(CFStringRef other) { |
| return CFStringEqual(i_ref, other); |
| } |
| |
| bool operator ==(CFStringRef other) const { |
| return CFStringEqual(i_ref, other); |
| } |
| |
| bool operator !=(CFStringRef other) { |
| return ! operator==(other); |
| } |
| |
| bool operator ==(const SuperString &other) { |
| return operator==(other.i_ref); |
| } |
| |
| bool operator ==(const SuperString &other) const { |
| return operator==(other.i_ref); |
| } |
| |
| bool operator !=(const SuperString &other) { |
| return ! operator==(other.i_ref); |
| } |
| |
| bool operator !=(SuperString &other) { |
| return ! operator==(other.i_ref); |
| } |
| |
| bool IsNumeric() const; |
| bool empty() const { return CFStringIsEmpty(i_ref); } |
| |
| /* |
| CFNumberRef CopyAs_NumberRef()' |
| CFDateRef CopyAs_DateRef()' |
| CFURLRef CopyAs_URLRef()' |
| |
| UInt32 GetAs_UInt32(); |
| UInt16 GetAs_UInt16(); |
| SInt16 GetAs_SInt16(); |
| */ |
| |
| OSType GetAs_OSType() const { return CharToOSType(utf8Z()); } |
| SInt32 GetAs_SInt32() const { return ::atoi(c_str()); } |
| float GetAs_Float() const { return CStringToFloat(c_str()); } |
| |
| OSType GetAsOSType() const { return GetAs_OSType(); } |
| long value_long() const { return GetAs_SInt32(); } |
| float value_float() const { return GetAs_Float(); } |
| |
| UInt32 hex_to_ulong() { return Hex_To_ULong(c_str()); } |
| |
| // returns *this |
| SuperString& ww_pop_front(long num_utf32_charsL = 1); |
| |
| // returns the chars popped off the front |
| SuperString pop_front(size_t numL = 1) { |
| SuperString str; |
| |
| if (utf8().size() <= numL) { |
| str.Set(*this); |
| clear(); |
| } else { |
| UCharVec bufAC(numL); |
| |
| std::copy(i_utf8->begin(), i_utf8->begin() + numL, &bufAC[0]); |
| bufAC.push_back(0); |
| |
| str.Set(&bufAC[0]); |
| Set(&(utf8().c_str())[numL]); |
| } |
| |
| return str; |
| } |
| |
| short count_match(const char *matchZ) { |
| short countS = 0; |
| const char *chZ = (const char *)utf8().c_str(); |
| |
| do { |
| chZ = strstr(chZ, matchZ); |
| if (chZ) { |
| ++countS; |
| ++chZ; |
| } |
| } while (chZ); |
| |
| return countS; |
| } |
| |
| bool rSplit(const char *splitZ, SuperString *lhsP0 = NULL, bool from_endB = false); |
| bool Split(const char *splitZ, SuperString *rhsP0 = NULL, bool from_endB = false); |
| |
| SuperString &pop_back(UInt32 numCharsL = 1); |
| |
| OSType &pop_ext(OSType *extP) const; |
| |
| OSType get_ext() const { |
| OSType ext; |
| |
| pop_ext(&ext); |
| return ext; |
| } |
| |
| SuperString &pop_ext(SuperString *extP0 = NULL) { |
| ustring ustr(utf8()); |
| const unsigned char *dotP; |
| |
| dotP = uc(strrchr(utf8Z(), '.')); |
| |
| if (dotP) { |
| if (extP0) { |
| extP0->Set(dotP); |
| } |
| |
| ustr.resize(ustr.size() - strlen((char *)dotP)); |
| |
| Set(ustr); |
| } |
| |
| return *this; |
| } |
| |
| /******************************/ |
| SuperString &resize(long num_utf8_charsL) { |
| ustring ustr(utf8()); |
| |
| ustr.resize(num_utf8_charsL); |
| Set(ustr); |
| return *this; |
| } |
| |
| SuperString &ww_resize(long num_utf32_charsL); |
| |
| SuperString &append(const ustring &other) { |
| Set(utf8() + other); |
| return *this; |
| } |
| |
| SuperString &append(SuperString &other) { |
| return append(other.utf8()); |
| } |
| |
| SuperString &append(CFStringRef myRef) { |
| return append(SuperString(myRef).utf8()); |
| } |
| |
| SuperString &append(const char *other) { |
| return append(SuperString(other).utf8()); |
| } |
| |
| SuperString &append(long valueL) |
| { |
| char bufAC[32]; |
| |
| ::sprintf(bufAC, "%ld", valueL); |
| return append(bufAC); |
| // std::string strStr; |
| |
| // return append(NumToCString(valueL, strStr)); |
| } |
| |
| SuperString &UnEscapeAmpersands(); |
| |
| SuperString &append(char ch) |
| { |
| char bufAC[2]; |
| |
| bufAC[0] = ch; |
| bufAC[1] = 0; |
| |
| SuperString appendStr(bufAC, kCFStringEncodingASCII); |
| |
| append(appendStr); |
| return *this; |
| } |
| |
| SuperString &append(float valueF, short precS = 1) |
| { |
| char bufAC[32]; |
| |
| CopyFloatToC(valueF, bufAC, precS); |
| return append(bufAC); |
| } |
| |
| /****************************/ |
| SuperString &prepend(const ustring &other) { |
| Set(other + utf8()); |
| return *this; |
| } |
| |
| SuperString &prepend(const SuperString &other) { |
| return prepend(other.utf8()); |
| } |
| |
| SuperString &prepend(const char *other) { |
| return prepend(SuperString(other).utf8()); |
| } |
| |
| SuperString &prepend(long valueL) { |
| char bufAC[32]; |
| |
| ::sprintf(bufAC, "%.2ld", valueL); |
| return prepend(bufAC); |
| } |
| |
| SuperString &Ascii(); |
| SuperString &Localize(); |
| }; |
| |
| SuperString operator+(const SuperString &lhs, SuperString rhs); |
| |
| char *OSTypeToChar(OSType osType, char *bufZ); |
| SuperString OSTypeToString(OSType osType); |
| void IncrementNumberAtEndOfString(SuperString *strP); |
| SuperString FormatBytes(UInt64 bytes); |
| |
| #if OPT_WINOS |
| inline SuperString SuperString_CreateFrom_UniChar( |
| UniCharCount sizeL, |
| const UniChar * nameA) |
| { |
| CF_ASSERT(nameA[sizeL] == 0); |
| return SuperString(reinterpret_cast<const wchar_t *>(nameA)); |
| } |
| #endif |
| |
| #if _KJ_MAC_ |
| void SP_VerifyStringExists(SP_IndexType stringType, SuperString *strP); |
| bool Dict_Get_Str(CFDictionaryRef dict, const char *keyZ, SuperString *strP); |
| SuperString Array_GetIndStr(CFArrayRef array, long indexL); |
| #endif |
| |
| typedef std::vector<SuperString> SStringVec; |
| |
| #endif |