Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-09-21 02:51:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

Cleaning in XString. Some method renaming.

Browse Source
This commit is contained in:
Jief L 2020-04-23 23:43:35 +03:00
parent 775d5abc5f
commit 73411bbc47
28 changed files with 260 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -127,4 +127,4 @@ tools
#Eclipse build folder #Eclipse build folder
/DEBUG_*/ /DEBUG_*/
/rEFIt_UEFI copy/ /rEFIt_UEFI copy*/

1
Xcode/CloverX64/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
/mtoc_path.txt

10
Xcode/CloverX64/CloverX64.xcodeproj/project.pbxproj
View File

@ -92,6 +92,7 @@
9A28CD34241BC0DF00F3D247 /* strncmp_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A28CD2E241BC0DF00F3D247 /* strncmp_test.cpp */; }; 9A28CD34241BC0DF00F3D247 /* strncmp_test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 9A28CD2E241BC0DF00F3D247 /* strncmp_test.cpp */; };
9A28CD35241BC0DF00F3D247 /* strlen_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A28CD2F241BC0DF00F3D247 /* strlen_test.h */; }; 9A28CD35241BC0DF00F3D247 /* strlen_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A28CD2F241BC0DF00F3D247 /* strlen_test.h */; };
9A28CD36241BC0DF00F3D247 /* strncmp_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A28CD30241BC0DF00F3D247 /* strncmp_test.h */; }; 9A28CD36241BC0DF00F3D247 /* strncmp_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A28CD30241BC0DF00F3D247 /* strncmp_test.h */; };
9A35A6182451FE1600CAFF76 /* XStringAbstract.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A35A6172451FE1500CAFF76 /* XStringAbstract.h */; };
9A4185B62439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; }; 9A4185B62439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; };
9A4185B72439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; }; 9A4185B72439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; };
9A4185B82439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; }; 9A4185B82439F29D00BEAFB8 /* LoadOptions_test.h in Headers */ = {isa = PBXBuildFile; fileRef = 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */; };
@ -889,6 +890,7 @@
9A28CD2E241BC0DF00F3D247 /* strncmp_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = strncmp_test.cpp; sourceTree = "<group>"; }; 9A28CD2E241BC0DF00F3D247 /* strncmp_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = strncmp_test.cpp; sourceTree = "<group>"; };
9A28CD2F241BC0DF00F3D247 /* strlen_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strlen_test.h; sourceTree = "<group>"; }; 9A28CD2F241BC0DF00F3D247 /* strlen_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strlen_test.h; sourceTree = "<group>"; };
9A28CD30241BC0DF00F3D247 /* strncmp_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strncmp_test.h; sourceTree = "<group>"; }; 9A28CD30241BC0DF00F3D247 /* strncmp_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = strncmp_test.h; sourceTree = "<group>"; };
9A35A6172451FE1500CAFF76 /* XStringAbstract.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XStringAbstract.h; sourceTree = "<group>"; };
9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LoadOptions_test.h; sourceTree = "<group>"; }; 9A4185B42439F29D00BEAFB8 /* LoadOptions_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LoadOptions_test.h; sourceTree = "<group>"; };
9A4185B52439F29D00BEAFB8 /* LoadOptions_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LoadOptions_test.cpp; sourceTree = "<group>"; }; 9A4185B52439F29D00BEAFB8 /* LoadOptions_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LoadOptions_test.cpp; sourceTree = "<group>"; };
9A9AEB90243F7B5600FBD7D8 /* unicode_conversions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = unicode_conversions.cpp; sourceTree = "<group>"; }; 9A9AEB90243F7B5600FBD7D8 /* unicode_conversions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = unicode_conversions.cpp; sourceTree = "<group>"; };
@ -1445,12 +1447,13 @@
children = ( children = (
9A9AEB90243F7B5600FBD7D8 /* unicode_conversions.cpp */, 9A9AEB90243F7B5600FBD7D8 /* unicode_conversions.cpp */,
9A9AEB93243F7B5600FBD7D8 /* unicode_conversions.h */, 9A9AEB93243F7B5600FBD7D8 /* unicode_conversions.h */,
9A9AEB91243F7B5600FBD7D8 /* XStringArray.cpp */,
9A9AEB92243F7B5600FBD7D8 /* XStringArray.h */,
9AC77FB624176C04005CDD5C /* XArray.h */, 9AC77FB624176C04005CDD5C /* XArray.h */,
9AC77FB724176C04005CDD5C /* XObjArray.h */, 9AC77FB724176C04005CDD5C /* XObjArray.h */,
9A28CC91241AB33700F3D247 /* XString.cpp */, 9A28CC91241AB33700F3D247 /* XString.cpp */,
9A28CC92241AB33700F3D247 /* XString.h */, 9A28CC92241AB33700F3D247 /* XString.h */,
9A35A6172451FE1500CAFF76 /* XStringAbstract.h */,
9A9AEB91243F7B5600FBD7D8 /* XStringArray.cpp */,
9A9AEB92243F7B5600FBD7D8 /* XStringArray.h */,
9AC77FAF24176C04005CDD5C /* XStringWArray.cpp */, 9AC77FAF24176C04005CDD5C /* XStringWArray.cpp */,
9AC77FAC24176C04005CDD5C /* XStringWArray.h */, 9AC77FAC24176C04005CDD5C /* XStringWArray.h */,
9AC77FB424176C04005CDD5C /* XToolsCommon.cpp */, 9AC77FB424176C04005CDD5C /* XToolsCommon.cpp */,
@ -1536,6 +1539,7 @@
9A28CD36241BC0DF00F3D247 /* strncmp_test.h in Headers */, 9A28CD36241BC0DF00F3D247 /* strncmp_test.h in Headers */,
9A105B7124483AE40006DE06 /* wchar.h in Headers */, 9A105B7124483AE40006DE06 /* wchar.h in Headers */,
9AC7804A24176C04005CDD5C /* XPointer.h in Headers */, 9AC7804A24176C04005CDD5C /* XPointer.h in Headers */,
9A35A6182451FE1600CAFF76 /* XStringAbstract.h in Headers */,
9AC7808E24176C04005CDD5C /* XToolsCommon.h in Headers */, 9AC7808E24176C04005CDD5C /* XToolsCommon.h in Headers */,
9AC7806D24176C04005CDD5C /* bootscreen.h in Headers */, 9AC7806D24176C04005CDD5C /* bootscreen.h in Headers */,
9AC7800E24176C04005CDD5C /* Settings.h in Headers */, 9AC7800E24176C04005CDD5C /* Settings.h in Headers */,
@ -2582,6 +2586,7 @@
"-fno-unwind-tables", "-fno-unwind-tables",
"-Wno-incompatible-ms-struct", "-Wno-incompatible-ms-struct",
"-Wreorder", "-Wreorder",
"-Wchar-subscripts",
); );
SUPPORTED_PLATFORMS = macosx; SUPPORTED_PLATFORMS = macosx;
USE_HEADERMAP = NO; USE_HEADERMAP = NO;
@ -2634,6 +2639,7 @@
"-fno-unwind-tables", "-fno-unwind-tables",
"-Wno-incompatible-ms-struct", "-Wno-incompatible-ms-struct",
"-Wreorder", "-Wreorder",
"-Wchar-subscripts",
); );
SUPPORTED_PLATFORMS = macosx; SUPPORTED_PLATFORMS = macosx;
USE_HEADERMAP = NO; USE_HEADERMAP = NO;

2
Xcode/CloverX64/clang-slink
View File

@ -66,7 +66,7 @@ ld -arch x86_64 -u __ModuleEntryPoint -e __ModuleEntryPoint -preload -segalign
source "$edk2prefix"/Conf/mtoc_path.txt source ./mtoc_path.txt
[[ $? == 0 ]] && "$MTOC" -subsystem UEFI_APPLICATION -align 0x20 ./"$outputname".dll ./"$outputname".pecoff [[ $? == 0 ]] && "$MTOC" -subsystem UEFI_APPLICATION -align 0x20 ./"$outputname".dll ./"$outputname".pecoff
[[ $? == 0 ]] && dsymutil ./"$outputname".dll [[ $? == 0 ]] && dsymutil ./"$outputname".dll

2
Xcode/cpp_tests/cpp_tests.xcodeproj/project.pbxproj
View File

@ -147,7 +147,6 @@
9A4185BE2439F73A00BEAFB8 /* XStringArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XStringArray.cpp; sourceTree = "<group>"; }; 9A4185BE2439F73A00BEAFB8 /* XStringArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XStringArray.cpp; sourceTree = "<group>"; };
9A4185BF2439F73A00BEAFB8 /* XStringArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XStringArray.h; sourceTree = "<group>"; }; 9A4185BF2439F73A00BEAFB8 /* XStringArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XStringArray.h; sourceTree = "<group>"; };
9A4FFA7C2451C8330050B38B /* XString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XString.cpp; sourceTree = "<group>"; }; 9A4FFA7C2451C8330050B38B /* XString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XString.cpp; sourceTree = "<group>"; };
9A4FFA7D2451C8330050B38B /* XStringAbstract copy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "XStringAbstract copy.h"; sourceTree = "<group>"; };
9A4FFA7F2451C88C0050B38B /* XString_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XString_test.h; sourceTree = "<group>"; }; 9A4FFA7F2451C88C0050B38B /* XString_test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XString_test.h; sourceTree = "<group>"; };
9A4FFA802451C88D0050B38B /* XString_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XString_test.cpp; sourceTree = "<group>"; }; 9A4FFA802451C88D0050B38B /* XString_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XString_test.cpp; sourceTree = "<group>"; };
9A57C20A2418A1FD0029A39F /* global_test.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = global_test.h; sourceTree = "<group>"; }; 9A57C20A2418A1FD0029A39F /* global_test.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = global_test.h; sourceTree = "<group>"; };
@ -210,7 +209,6 @@
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
9A4FFA7C2451C8330050B38B /* XString.cpp */, 9A4FFA7C2451C8330050B38B /* XString.cpp */,
9A4FFA7D2451C8330050B38B /* XStringAbstract copy.h */,
9A57C266241A799B0029A39F /* XString.h */, 9A57C266241A799B0029A39F /* XString.h */,
9A6BA73C2449977300BDA52C /* XStringAbstract.h */, 9A6BA73C2449977300BDA52C /* XStringAbstract.h */,
9A9AEB8C243F73CE00FBD7D8 /* unicode_conversions.cpp */, 9A9AEB8C243F73CE00FBD7D8 /* unicode_conversions.cpp */,

6
Xcode/cpp_tests/src/Platform.cpp
View File

@ -99,7 +99,7 @@ void* AllocatePool(UINTN AllocationSize)
void* AllocateZeroPool(UINTN AllocationSize) void* AllocateZeroPool(UINTN AllocationSize)
{ {
void* p = (void*)malloc((size_t)AllocationSize); void* p = (void*)malloc((size_t)AllocationSize);
memset(p, 0, AllocationSize); memset(p, 0, (size_t)AllocationSize);
return p; return p;
} }
@ -117,12 +117,12 @@ void FreePool(const void* Buffer)
void ZeroMem(void *Destination, UINTN Length) void ZeroMem(void *Destination, UINTN Length)
{ {
memset(Destination, 0, Length); memset(Destination, 0, (size_t)Length);
} }
void SetMem(void *Destination, UINTN Length, char c) void SetMem(void *Destination, UINTN Length, char c)
{ {
memset(Destination, c, Length); memset(Destination, c, (size_t)Length);
} }
void CopyMem(void *Destination, void *Source, UINTN Length) void CopyMem(void *Destination, void *Source, UINTN Length)

4
Xcode/cpp_tests/src/Platform.h
View File

@ -56,6 +56,10 @@ typedef UINTN RETURN_STATUS;
#define OPTIONAL #define OPTIONAL
#define ASSERT(x) #define ASSERT(x)
#ifdef _MSC_VER
#define __typeof__(x) decltype(x)
#endif
void CpuDeadLoop(void); void CpuDeadLoop(void);
void DebugLog(INTN DebugMode, const char *FormatString, ...); void DebugLog(INTN DebugMode, const char *FormatString, ...);

10
Xcode/cpp_tests/src/main.cpp
View File

@ -18,12 +18,12 @@ extern "C" int main(int argc, const char * argv[])
(void)argv; (void)argv;
setlocale(LC_ALL, "en_US"); // to allow printf unicode char setlocale(LC_ALL, "en_US"); // to allow printf unicode char
printf("sizeof(wchar_t)=%lu\n", sizeof(wchar_t)); printf("sizeof(wchar_t)=%zu\n", sizeof(wchar_t));
printf("%lc\n", L'Ľ'); printf("%lc\n", L'Ľ');
printf("sizeof(size_t)=%lu\n", sizeof(size_t)); printf("sizeof(size_t)=%zu\n", sizeof(size_t));
printf("sizeof(long)=%lu\n", sizeof(long)); printf("sizeof(long)=%zu\n", sizeof(long));
printf("sizeof(long long)=%lu\n", sizeof(long long)); printf("sizeof(long long)=%zu\n", sizeof(long long));
printf("sizeof(size_t)=%lu\n", sizeof(size_t)); printf("sizeof(size_t)=%zu\n", sizeof(size_t));
#ifndef _MSC_VER #ifndef _MSC_VER
//printf("%zu\n", (size_t)MAX_UINT64); //printf("%zu\n", (size_t)MAX_UINT64);
//printf("%zd\n", (size_t)MAX_UINT64); //printf("%zd\n", (size_t)MAX_UINT64);

6
ebuild.sh
View File

@ -414,7 +414,7 @@ checkCmdlineArguments() {
checkToolchain() { checkToolchain() {
case "$TOOLCHAIN" in case "$TOOLCHAIN" in
XCLANG|XCODE*) checkXcode ;; XCLANG|XCODE*) checkXcode ;;
*) export MTOC_PREFIX="${TOOLCHAIN_DIR}/bin/" ;; *) ;;
esac esac
if [[ "$SYSNAME" == Linux ]]; then if [[ "$SYSNAME" == Linux ]]; then
@ -500,7 +500,9 @@ MainBuildScript() {
set +u set +u
source ./edksetup.sh BaseTools source ./edksetup.sh BaseTools
set -u set -u
echo "MTOC=$MTOC_PREFIX/mtoc.NEW_jief" > "$WORKSPACE"/Conf/mtoc_path.txt if [ ! -z "${MTOC_PREFIX:-}" ]; then
echo "MTOC=$MTOC_PREFIX/mtoc.NEW_jief" > "$WORKSPACE"/Xcode/CloverX64/mtoc_path.txt
fi
cd "$CLOVERROOT" cd "$CLOVERROOT"
# else # else
# echo "Building from: $WORKSPACE" # echo "Building from: $WORKSPACE"

2
rEFIt_UEFI/Platform/Settings.cpp
View File

@ -8044,7 +8044,7 @@ SetFSInjection (
} }
// check if blocking of caches is needed // check if blocking of caches is needed
if ( OSFLAG_ISSET(Entry->Flags, OSFLAG_NOCACHES) || Entry->LoadOptions.ExistIn("-f") ) { if ( OSFLAG_ISSET(Entry->Flags, OSFLAG_NOCACHES) || Entry->LoadOptions.contains("-f") ) {
MsgLog ("Blocking kext caches\n"); MsgLog ("Blocking kext caches\n");
// BlockCaches = TRUE; // BlockCaches = TRUE;
// add caches to blacklist // add caches to blacklist

18
rEFIt_UEFI/cpp_foundation/XArray.h
View File

@ -63,10 +63,14 @@ class XArray
const TYPE& ElementAt(int nIndex) const; const TYPE& ElementAt(int nIndex) const;
TYPE& ElementAt(int nIndex); TYPE& ElementAt(int nIndex);
const TYPE& operator[](xsize nIndex) const { return ElementAt(nIndex); } // const TYPE& operator[](xsize nIndex) const { return ElementAt(nIndex); }
TYPE& operator[](xsize nIndex) { return ElementAt(nIndex); } // TYPE& operator[](xsize nIndex) { return ElementAt(nIndex); }
const TYPE& operator[]( int nIndex) const { return ElementAt(nIndex); } // const TYPE& operator[]( int nIndex) const { return ElementAt(nIndex); }
TYPE& operator[]( int nIndex) { return ElementAt(nIndex); } TYPE& operator[]( int nIndex) { return ElementAt(nIndex); }
// const TYPE& operator[]( unsigned long long nIndex) const { return ElementAt((size_t)nIndex); }
// const TYPE& operator[]( long long nIndex) const { return ElementAt((size_t)nIndex); }
TYPE& operator[]( unsigned long long nIndex) { return ElementAt((size_t)nIndex); }
TYPE& operator[]( long long nIndex) { return ElementAt((size_t)nIndex); }
operator const void *() const { return m_data; }; operator const void *() const { return m_data; };
operator void *() { return m_data; }; operator void *() { return m_data; };
@ -102,8 +106,8 @@ class XArray
void setEmpty(); void setEmpty();
bool isEmpty() const { return size() == 0; } bool isEmpty() const { return size() == 0; }
xsize IdxOf(TYPE& e) const; xsize indexOf(TYPE& e) const;
bool ExistIn(TYPE& e) const { return IdxOf(e) != MAX_XSIZE; } //logically it should be named as Contains(e) bool contains(TYPE& e) const { return indexOf(e) != MAX_XSIZE; } //logically it should be named as Contains(e)
}; };
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
@ -113,7 +117,7 @@ class XArray
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
template<class TYPE> template<class TYPE>
xsize XArray<TYPE>::IdxOf(TYPE& e) const xsize XArray<TYPE>::indexOf(TYPE& e) const
{ {
xsize i; xsize i;
@ -181,7 +185,7 @@ void XArray<TYPE>::CheckSize(xsize nNewSize, xsize nGrowBy)
nNewSize += nGrowBy; nNewSize += nGrowBy;
m_data = (TYPE *)realloc((void *)m_data, nNewSize * sizeof(TYPE), m_allocatedSize * sizeof(TYPE) ); m_data = (TYPE *)realloc((void *)m_data, nNewSize * sizeof(TYPE), m_allocatedSize * sizeof(TYPE) );
if ( !m_data ) { if ( !m_data ) {
DebugLog(2, "XArray<TYPE>::CheckSize(nNewSize=%llu, nGrowBy=%llu) : Xrealloc(%llu, %llu, %" PRIuPTR ") returned NULL. System halted\n", nNewSize, nGrowBy, m_allocatedSize, nNewSize*sizeof(TYPE), (uintptr_t)m_data); DebugLog(2, "XArray<TYPE>::CheckSize(nNewSize=%zu, nGrowBy=%zu) : Xrealloc(%zu, %lu, %" PRIuPTR ") returned NULL. System halted\n", nNewSize, nGrowBy, m_allocatedSize, nNewSize*sizeof(TYPE), (uintptr_t)m_data);
panic(); panic();
} }
// memset(&_Data[_Size], 0, (nNewSize-_Size) * sizeof(TYPE)); // Could help for debugging, but zeroing in not needed. // memset(&_Data[_Size], 0, (nNewSize-_Size) * sizeof(TYPE)); // Could help for debugging, but zeroing in not needed.

8
rEFIt_UEFI/cpp_foundation/XObjArray.h
View File

@ -183,7 +183,7 @@ void XObjArrayNC<TYPE>::CheckSize(xsize nNewSize, xsize nGrowBy)
nNewSize += nGrowBy + 1; nNewSize += nGrowBy + 1;
_Data = (XObjArrayEntry<TYPE> *)realloc((void *)_Data, sizeof(XObjArrayEntry<TYPE>) * nNewSize, sizeof(XObjArrayEntry<TYPE>) * m_allocatedSize); _Data = (XObjArrayEntry<TYPE> *)realloc((void *)_Data, sizeof(XObjArrayEntry<TYPE>) * nNewSize, sizeof(XObjArrayEntry<TYPE>) * m_allocatedSize);
if ( !_Data ) { if ( !_Data ) {
DebugLog(2, "XObjArrayNC<TYPE>::CheckSize(nNewSize=%llu, nGrowBy=%llu) : Xrealloc(%llu, %llu, %" PRIuPTR ") returned NULL. System halted\n", nNewSize, nGrowBy, m_allocatedSize, sizeof(XObjArrayEntry<TYPE>) * nNewSize, (uintptr_t)_Data); DebugLog(2, "XObjArrayNC<TYPE>::CheckSize(nNewSize=%zu, nGrowBy=%zu) : Xrealloc(%zu, %zu, %" PRIuPTR ") returned NULL. System halted\n", nNewSize, nGrowBy, m_allocatedSize, sizeof(XObjArrayEntry<TYPE>) * nNewSize, (uintptr_t)_Data);
panic(); panic();
} }
// memset(&_Data[m_allocatedSize], 0, (nNewSize-m_allocatedSize) * sizeof(XObjArrayEntry<TYPE>)); // memset(&_Data[m_allocatedSize], 0, (nNewSize-m_allocatedSize) * sizeof(XObjArrayEntry<TYPE>));
@ -196,7 +196,7 @@ template<class TYPE>
TYPE &XObjArrayNC<TYPE>::ElementAt(xsize index) TYPE &XObjArrayNC<TYPE>::ElementAt(xsize index)
{ {
if ( index >= _Len ) { if ( index >= _Len ) {
DebugLog(2, "XObjArray<TYPE>::ElementAt(xsize) -> operator [] - index (%llu) greater than length (%llu)\n", index, _Len); DebugLog(2, "XObjArray<TYPE>::ElementAt(xsize) -> operator [] - index (%zu) greater than length (%zu)\n", index, _Len);
panic(); panic();
} }
return *((TYPE *)(_Data[index].Object)); return *((TYPE *)(_Data[index].Object));
@ -207,7 +207,7 @@ template<class TYPE>
const TYPE &XObjArrayNC<TYPE>::ElementAt(xsize index) const const TYPE &XObjArrayNC<TYPE>::ElementAt(xsize index) const
{ {
if ( index >= _Len ) { if ( index >= _Len ) {
DebugLog(2, "XObjArray<TYPE>::ElementAt(xsize) const -> operator [] - index (%llu) greater than length (%llu)\n", index, _Len); DebugLog(2, "XObjArray<TYPE>::ElementAt(xsize) const -> operator [] - index (%zu) greater than length (%zu)\n", index, _Len);
panic(); panic();
} }
return *((TYPE *)(_Data[index].Object)); return *((TYPE *)(_Data[index].Object));
@ -427,7 +427,7 @@ void XObjArrayNC<TYPE>::RemoveAtIndex(xsize nIndex)
if ( nIndex < XObjArrayNC<TYPE>::_Len ) if ( nIndex < XObjArrayNC<TYPE>::_Len )
{ {
if ( nIndex >= XObjArrayNC<TYPE>::_Len ) { if ( nIndex >= XObjArrayNC<TYPE>::_Len ) {
DebugLog(2, "void XObjArrayNC<TYPE>::RemoveAtIndex(xsize nIndex) : BUG nIndex (%llu) is > length(). System halted\n", nIndex); DebugLog(2, "void XObjArrayNC<TYPE>::RemoveAtIndex(xsize nIndex) : BUG nIndex (%zu) is > length(). System halted\n", nIndex);
panic(); panic();
} }
} }

5
rEFIt_UEFI/cpp_foundation/XString.h
View File

@ -140,4 +140,9 @@ extern const XStringW NullXStringW;
XString SPrintf(const char* format, ...) __attribute__((__format__ (__printf__, 1, 2))); XString SPrintf(const char* format, ...) __attribute__((__format__ (__printf__, 1, 2)));
XStringW SWPrintf(const char* format, ...) __attribute__((__format__ (__printf__, 1, 2))); XStringW SWPrintf(const char* format, ...) __attribute__((__format__ (__printf__, 1, 2)));
//
//XStringAbstract SubString(const T *S, size_t pos, size_t count);
//XStringAbstract CleanCtrl(const XStringAbstract &S);
#endif #endif

170
rEFIt_UEFI/cpp_foundation/XStringAbstract.h
View File

@ -49,9 +49,9 @@ struct XStringAbstract__true_type {
template <class _Tp> template <class _Tp>
struct XStringAbstract__make_unsigned {}; struct XStringAbstract__make_unsigned {};
//template <> struct __make_unsigned<bool, true> {}; template <> struct XStringAbstract__make_unsigned< char> {typedef unsigned char type;};
template <> struct XStringAbstract__make_unsigned< signed char> {typedef unsigned short type;}; template <> struct XStringAbstract__make_unsigned< signed char> {typedef unsigned char type;};
template <> struct XStringAbstract__make_unsigned<unsigned char> {typedef unsigned short type;}; template <> struct XStringAbstract__make_unsigned<unsigned char> {typedef unsigned char type;};
template <> struct XStringAbstract__make_unsigned< signed short> {typedef unsigned short type;}; template <> struct XStringAbstract__make_unsigned< signed short> {typedef unsigned short type;};
template <> struct XStringAbstract__make_unsigned<unsigned short> {typedef unsigned short type;}; template <> struct XStringAbstract__make_unsigned<unsigned short> {typedef unsigned short type;};
template <> struct XStringAbstract__make_unsigned< signed int> {typedef unsigned int type;}; template <> struct XStringAbstract__make_unsigned< signed int> {typedef unsigned int type;};
@ -60,6 +60,7 @@ template <> struct XStringAbstract__make_unsigned< signed long> {typedef unsign
template <> struct XStringAbstract__make_unsigned<unsigned long> {typedef unsigned long type;}; template <> struct XStringAbstract__make_unsigned<unsigned long> {typedef unsigned long type;};
template <> struct XStringAbstract__make_unsigned< signed long long> {typedef unsigned long long type;}; template <> struct XStringAbstract__make_unsigned< signed long long> {typedef unsigned long long type;};
template <> struct XStringAbstract__make_unsigned<unsigned long long> {typedef unsigned long long type;}; template <> struct XStringAbstract__make_unsigned<unsigned long long> {typedef unsigned long long type;};
#define unsigned_type(x) typename XStringAbstract__make_unsigned<x>::type
/* enable_if */ /* enable_if */
template <bool, typename T = void> template <bool, typename T = void>
@ -210,22 +211,7 @@ size_t XStringAbstract__rindexOf(const O* s, size_t Pos, const P* other, bool to
return MAX_XSIZE; return MAX_XSIZE;
} }
//template<typename O, typename P>
//size_t XStringAbstract__rindexOf(const O* s, size_t Pos, const P* other, bool toLower)
//{
// size_t index = XStringAbstract__indexOf(s, 0, other, toLower);
// size_t prev_index = index; // initialize to index in case of index is already == Pos
// while ( index < Pos ) {
// prev_index = index;
// index = XStringAbstract__indexOf(s, index+1, other, toLower);
// };
// if ( index == Pos ) return index;
// if ( prev_index <= Pos ) return prev_index;
// return MAX_XSIZE;
//}
//template<class T, class SubType, size_t growBy>
template<class T, class ThisXStringClass> template<class T, class ThisXStringClass>
class XStringAbstract class XStringAbstract
{ {
@ -233,13 +219,6 @@ public:
// const SubType NullXString; // const SubType NullXString;
static T nullChar; static T nullChar;
//class XString16;
// XStringAbstract<T, ThisXStringClass>(const XStringAbstract<T, ThisXStringClass> &S)
// {
// Init(0);
// takeValueFrom(S);
// }
protected: protected:
T *m_data; T *m_data;
size_t m_allocatedSize; size_t m_allocatedSize;
@ -255,7 +234,7 @@ protected:
T* _data(IntegralType pos) const T* _data(IntegralType pos) const
{ {
if ( pos<0 ) panic("T* data(int i) -> i < 0"); if ( pos<0 ) panic("T* data(int i) -> i < 0");
size_t offset = size_of_utf_string_len(m_data, (typename XStringAbstract__make_unsigned<IntegralType>::type)pos); // If pos is too big, size_of_utf_string_len returns the end of the string size_t offset = size_of_utf_string_len(m_data, (unsigned_type(IntegralType))pos); // If pos is too big, size_of_utf_string_len returns the end of the string
return m_data + offset; return m_data + offset;
} }
@ -327,8 +306,9 @@ public:
template<typename IntegralType, enable_if(is_integral(IntegralType))> template<typename IntegralType, enable_if(is_integral(IntegralType))>
T* dataSized(IntegralType size) T* dataSized(IntegralType size)
{ {
if ( size<0 ) panic("T* dataSized(xisize i, size_t sizeMin, size_t nGrowBy) -> i < 0"); if ( size<0 ) panic("T* dataSized() -> i < 0");
CheckSize((typename XStringAbstract__make_unsigned<IntegralType>::type)size); if ( (unsigned_type(IntegralType))size > MAX_XSIZE ) panic("T* dataSized() -> i > MAX_XSIZE");
CheckSize((size_t)size);
return _data(0); return _data(0);
} }
// //
@ -343,17 +323,6 @@ public:
// return _data(pos); // return _data(pos);
// } // }
// const T* data(unsigned int ui) const { return _data(ui); }
// const T* data(int i) const { return _data(i); }
// const T* data(size_t ui) const { return _data(ui); }
// const T* data(xisize i) const { return _data(i); }
//
// T* dataSized(unsigned int ui, size_t sizeMin, size_t nGrowBy=16) { CheckSize(ui+sizeMin, nGrowBy); return _data(ui); }
// T* dataSized(unsigned long ui, size_t sizeMin, size_t nGrowBy=16) { CheckSize(ui+sizeMin, nGrowBy); return _data(ui); }
// T* dataSized(unsigned long long ui, size_t sizeMin, size_t nGrowBy=16) { CheckSize(ui+sizeMin, nGrowBy); return _data(ui); }
// T* dataSized(int i, size_t sizeMin, size_t nGrowBy=16) { if ( i<0 ) panic("T* dataSized(xisize i, size_t sizeMin, size_t nGrowBy) -> i < 0"); CheckSize((unsigned int)i+sizeMin, nGrowBy); return _data(i); }
// T* dataSized(long i, size_t sizeMin, size_t nGrowBy=16) { if ( i<0 ) panic("T* dataSized(xisize i, size_t sizeMin, size_t nGrowBy) -> i < 0"); CheckSize((unsigned long)i+sizeMin, nGrowBy); return _data(i); }
// T* dataSized(long long i, size_t sizeMin, size_t nGrowBy=16) { if ( i<0 ) panic("T* dataSized(xisize i, size_t sizeMin, size_t nGrowBy) -> i < 0"); CheckSize((unsigned long long)i+sizeMin, nGrowBy); return _data(i); }
T* forgetDataWithoutFreeing() T* forgetDataWithoutFreeing()
{ {
@ -403,7 +372,7 @@ public:
panic("XStringAbstract::char32At(size_t i) : i >= length(). System halted\n"); panic("XStringAbstract::char32At(size_t i) : i >= length(). System halted\n");
} }
nb += 1; nb += 1;
} while (nb <= (typename XStringAbstract__make_unsigned<IntegralType>::type)i ); } while (nb <= (unsigned_type(IntegralType))i);
return char32; return char32;
} }
@ -496,16 +465,16 @@ public:
/* ctor */ /* ctor */
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
explicit XStringAbstract<T, ThisXStringClass>(const XStringAbstract<O, OtherXStringClass>& S) { Init(0); takeValueFrom(S); } explicit XStringAbstract<T, ThisXStringClass>(const XStringAbstract<O, OtherXStringClass>& S) { Init(0); takeValueFrom(S); }
template<typename O> // template<typename O>
explicit XStringAbstract<T, ThisXStringClass>(const O* S) { Init(0); takeValueFrom(S); } // explicit XStringAbstract<T, ThisXStringClass>(const O* S) { Init(0); takeValueFrom(S); }
/* Copy Assign */ // Only other XString, no litteral at the moment. /* Copy Assign */ // Only other XString, no litteral at the moment.
XStringAbstract<T, ThisXStringClass>& operator =(const XStringAbstract<T, ThisXStringClass>& S) { strcpy(S.s()); return *this; } XStringAbstract<T, ThisXStringClass>& operator =(const XStringAbstract<T, ThisXStringClass>& S) { strcpy(S.s()); return *this; }
/* Assign */ /* Assign */
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
ThisXStringClass& operator =(const XStringAbstract<O, OtherXStringClass>& S) { strcpy(S.s()); return *((ThisXStringClass*)this); } ThisXStringClass& operator =(const XStringAbstract<O, OtherXStringClass>& S) { strcpy(S.s()); return *((ThisXStringClass*)this); }
template<class O> // template<class O>
ThisXStringClass& operator =(const O* S) { strcpy(S); return *this; } // ThisXStringClass& operator =(const O* S) { strcpy(S); return *this; }
/* += */ /* += */
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
@ -513,13 +482,6 @@ public:
template<typename O> template<typename O>
ThisXStringClass& operator += (const O* S) { strcat(S); return *((ThisXStringClass*)this); } ThisXStringClass& operator += (const O* S) { strcat(S); return *((ThisXStringClass*)this); }
// + operator
// template<typename XStringClass, class OtherXStringClass>
// friend ThisXStringClass operator + (const XStringClass& p1, const XStringAbstract<O, OtherXStringClass>& p2) { XStringAbstract s; s=p1; s+=p2; return s; }
// template<typename O, enable_if(is_char(O))>
// friend ThisXStringClass operator + (const XStringAbstract<T, ThisXStringClass>& p1, const O* p2 ) { XStringAbstract s; s=p1; s+=p2; return s; }
// template<typename O, class OtherXStringClass, enable_if(is_char(O))>
// friend ThisXStringClass operator + (const O *p1, const XStringAbstract<T, ThisXStringClass>& p2) { XStringAbstract s; s.strcat(p1); s.strcat(p2.s()); return s; }
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
ThisXStringClass operator + (const XStringAbstract<O, OtherXStringClass>& p2) const { XStringAbstract s; s=*this; s+=p2; return s; } ThisXStringClass operator + (const XStringAbstract<O, OtherXStringClass>& p2) const { XStringAbstract s; s=*this; s+=p2; return s; }
@ -541,10 +503,6 @@ public:
size_t indexOf(const O* S, size_t Pos = 0) const { return XStringAbstract__indexOf(m_data, Pos, S, false); } size_t indexOf(const O* S, size_t Pos = 0) const { return XStringAbstract__indexOf(m_data, Pos, S, false); }
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
size_t indexOf(const XStringAbstract<O, OtherXStringClass>& S, size_t Pos = 0) const { return indexOf(S.s(), Pos); } size_t indexOf(const XStringAbstract<O, OtherXStringClass>& S, size_t Pos = 0) const { return indexOf(S.s(), Pos); }
// old name : todo remove
size_t IdxOf(char c, size_t Pos = 0) const { return indexOf((char32_t)c, Pos); }
template<typename O, class OtherXStringClass>
size_t IdxOf(const XStringAbstract<O, OtherXStringClass>& S, size_t Pos = 0) const { return indexOf(S, Pos); }
/* IC */ /* IC */
size_t indexOfIC(char32_t char32Searched, size_t Pos = 0) const size_t indexOfIC(char32_t char32Searched, size_t Pos = 0) const
{ {
@ -614,7 +572,7 @@ public:
// } // }
//} //}
XStringAbstract SubString(size_t pos, size_t count) const XStringAbstract subString(size_t pos, size_t count) const
{ {
if ( count > length()-pos ) count = length()-pos; if ( count > length()-pos ) count = length()-pos;
XStringAbstract ret; XStringAbstract ret;
@ -631,13 +589,13 @@ public:
// todo rename to contains // todo rename to contains
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
bool ExistIn(const XStringAbstract<O, OtherXStringClass>& S) const { return indexOf(S) != MAX_XSIZE; } bool contains(const XStringAbstract<O, OtherXStringClass>& S) const { return indexOf(S) != MAX_XSIZE; }
template<typename O> template<typename O>
bool ExistIn(const O* S) const { return indexOf(S) != MAX_XSIZE; } bool contains(const O* S) const { return indexOf(S) != MAX_XSIZE; }
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
size_t ExistInIC(const XStringAbstract<O, OtherXStringClass>& S) const { return indexOfIC(S) != MAX_XSIZE; } size_t containsIC(const XStringAbstract<O, OtherXStringClass>& S) const { return indexOfIC(S) != MAX_XSIZE; }
template<typename O> template<typename O>
size_t ExistInIC(const O* S) const { return indexOfIC(S) != MAX_XSIZE; } size_t containsIC(const O* S) const { return indexOfIC(S) != MAX_XSIZE; }
// void ToLower(bool FirstCharIsCap = false); // void ToLower(bool FirstCharIsCap = false);
@ -723,12 +681,10 @@ public:
// int Compare(const wchar_t* S) const { return ::Compare<T, wchar_t>(m_data, S); }; // int Compare(const wchar_t* S) const { return ::Compare<T, wchar_t>(m_data, S); };
// //
template<typename O, class OtherXStringClass> template<typename O, class OtherXStringClass>
bool Equal(const O* S) const { return XStringAbstract__compare(m_data, S, false); } bool equalIC(const XStringAbstract<O, OtherXStringClass>& S) const { return XStringAbstract__compare(m_data, S.s(), true) == 0; }
template<typename O, class OtherXStringClass>
bool EqualIC(const XStringAbstract<O, OtherXStringClass>& S) const { return XStringAbstract__compare(m_data, S.s(), true); }
template<typename O> template<typename O>
bool EqualIC(const O* S) const { return XStringAbstract__compare(m_data, S, true); } bool equalIC(const O* S) const { return XStringAbstract__compare(m_data, S, true) == 0; }
// bool BeginingEqual(const T* S) const { return (memcmp(data(), S, wcslen(S)) == 0); } // bool startWith(const T* S) const { return (memcmp(data(), S, wcslen(S)) == 0); }
// bool SubStringEqual(size_t Pos, const T* S) const { return (memcmp(data(Pos), S, wcslen(S)) == 0); } // bool SubStringEqual(size_t Pos, const T* S) const { return (memcmp(data(Pos), S, wcslen(S)) == 0); }
public: public:
@ -784,18 +740,6 @@ T XStringAbstract<T, ThisXStringClass>::nullChar = 0;
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// Constructor
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//
//template<class T, class SubType, size_t growBy>
//XStringAbstract<T>::XStringAbstract(const XStringAbstract &aString)
//{
//DBG_XSTRING("Constructor(const XStringAbstract &aString) : %ls\n", aString.data());
// Init(aString.size());
// memcpy(m_data, aString.m_data, aString.sizeInBytes());
//}
// //
@ -838,57 +782,6 @@ T XStringAbstract<T, ThisXStringClass>::nullChar = 0;
//-----------------------------------------------------------------------------
// Functions
//-----------------------------------------------------------------------------
//XStringAbstract operator"" _XSW ( const T* s, size_t len)
//{
// XStringAbstract returnValue;
// if ( len > MAX_XSIZE ) len = MAX_XSIZE;
// returnValue.takeValueFrom(s, len);
// return returnValue; // don't do "return returnValue.takeValueFrom(s, len)" because it break the return value optimization.
//}
//
//XStringAbstract SWPrintf(const char* format, ...)
//{
// va_list va;
// XStringAbstract str;
//
// va_start (va, format);
// str.vSWPrintf(format, va);
// va_end(va);
//
// return str;
//}
//
//XStringAbstract SubString(const T *S, size_t pos, size_t count)
//{
// if ( wcslen(S)-pos < count ) count = wcslen(S)-pos;
// XStringAbstract ret;
// ret.StrnCpy(S+pos, count);
//// return ( XStringAbstract(S+pos, count) );
// return ret;
//}
//
//
//XStringAbstract CleanCtrl(const XStringAbstract &S)
//{
// XStringAbstract ReturnValue;
// size_t i;
//
// for ( i=0 ; i<S.size() ; i+=1 ) {
//#if __WCHAR_MIN__ < 0
// if ( S.wc_str()[i] >=0 && S.wc_str()[i] < ' ' ) ReturnValue += 'x'; /* T are signed */
//#else
// if ( S.wc_str()[i] < ' ' ) ReturnValue += 'x'; /* T are unsigned */
//#endif
// else ReturnValue += S.wc_str()[i];
// }
// return ReturnValue;
//}
@ -897,24 +790,11 @@ T XStringAbstract<T, ThisXStringClass>::nullChar = 0;
#undef DBG_XSTRING #undef DBG_XSTRING
#undef is_integral
//#undef enable_if
#undef asciiToLower #undef asciiToLower
#undef unsigned_type
#undef is_integral
#undef is_char
#undef enable_if
//
//extern const XStringAbstract NullXStringAbstract;
//
//XStringAbstract operator"" _XSW ( const T* s, size_t len);
//
//XStringAbstract SWPrintf(const char* format, ...) __attribute__((__format__(__printf__, 1, 2)));
//XStringAbstract SubString(const T *S, size_t pos, size_t count);
//XStringAbstract CleanCtrl(const XStringAbstract &S);

10
rEFIt_UEFI/cpp_foundation/XStringArray.cpp
View File

@ -124,16 +124,16 @@ void XStringArray::AddID(const XStringArray &aStrings)
XStringArray Split(const XString &S, const XString &Separator) XStringArray Split(const XString &S, const XString &Separator)
{ {
XStringArray Ss; XStringArray Ss;
xsize idxB, idxE; size_t idxB, idxE;
idxB = 0; idxB = 0;
idxE = S.IdxOf(Separator, idxB); idxE = S.indexOf(Separator, idxB);
while ( idxE != MAX_XSIZE ) { while ( idxE != MAX_XSIZE ) {
Ss.AddCopy(S.SubString(idxB, idxE-idxB)); Ss.AddCopy(S.subString(idxB, idxE-idxB));
idxB = idxE + Separator.length(); idxB = idxE + Separator.length();
idxE = S.IdxOf(Separator, idxB); idxE = S.indexOf(Separator, idxB);
} }
if ( idxB < S.length() ) Ss.AddCopy(S.SubString(idxB, S.length()-idxB)); if ( idxB < S.length() ) Ss.AddCopy(S.subString(idxB, S.length()-idxB));
return Ss; return Ss;
} }

4
rEFIt_UEFI/cpp_foundation/XStringWArray.cpp
View File

@ -132,11 +132,11 @@ XStringWArray Split(const XStringW &S, const XStringW &Separator)
idxB = 0; idxB = 0;
idxE = S.indexOf(Separator, idxB); idxE = S.indexOf(Separator, idxB);
while ( idxE != MAX_XSIZE ) { while ( idxE != MAX_XSIZE ) {
Ss.AddCopy(S.SubString(idxB, idxE-idxB)); Ss.AddCopy(S.subString(idxB, idxE-idxB));
idxB = idxE + Separator.length(); idxB = idxE + Separator.length();
idxE = S.indexOf(Separator, idxB); idxE = S.indexOf(Separator, idxB);
} }
if ( idxB < S.length() ) Ss.AddCopy(S.SubString(idxB, S.length()-idxB)); if ( idxB < S.length() ) Ss.AddCopy(S.subString(idxB, S.length()-idxB));
return Ss; return Ss;
} }

8
rEFIt_UEFI/cpp_foundation/XToolsCommon.h
View File

@ -4,10 +4,10 @@
#include <posix.h> #include <posix.h>
#define xsize UINTN #define xsize size_t
#define xisize INTN //#define xisize INTN
#define MAX_XSIZE MAX_UINTN #define MAX_XSIZE SIZE_T_MAX
#define MAX_XISIZE MAX_INTN //#define MAX_XISIZE MAX_INTN
extern xsize XArrayGrowByDefault; extern xsize XArrayGrowByDefault;
extern xsize XBufferGrowByDefault; extern xsize XBufferGrowByDefault;

6
rEFIt_UEFI/cpp_unit_test/LoadOptions_test.cpp
View File

@ -15,7 +15,7 @@ CHAR16 *Old1_AddLoadOption(IN CONST CHAR16 *LoadOptions, IN CONST CHAR16 *LoadOp
return EfiStrDuplicate(LoadOption); return EfiStrDuplicate(LoadOption);
} }
// If there is no option or it is already present duplicate original // If there is no option or it is already present duplicate original
// with XStringW it will be replaced by if (LoadOptions.ExistIn(LoadOption)) // with XStringW it will be replaced by if (LoadOptions.contains(LoadOption))
else if ((LoadOption == NULL) || StrStr(LoadOptions, LoadOption)) else if ((LoadOption == NULL) || StrStr(LoadOptions, LoadOption))
return EfiStrDuplicate(LoadOptions); return EfiStrDuplicate(LoadOptions);
// Otherwise add option // Otherwise add option
@ -97,7 +97,7 @@ CHAR16 *Old1_RemoveLoadOption(IN CONST CHAR16 *LoadOptions, IN CONST CHAR16 *Loa
// } // }
// // If there is no option or it is already present duplicate original // // If there is no option or it is already present duplicate original
// else { // else {
// if ( LoadOptions.ExistIn(LoadOption) ) return LoadOptions; // if ( LoadOptions.contains(LoadOption) ) return LoadOptions;
// // Otherwise add option // // Otherwise add option
// return SPrintf("%s %s", LoadOptions.c_str(), LoadOption.c_str()); //LoadOptions + LoadOption // return SPrintf("%s %s", LoadOptions.c_str(), LoadOption.c_str()); //LoadOptions + LoadOption
// } // }
@ -115,7 +115,7 @@ CHAR16 *Old1_RemoveLoadOption(IN CONST CHAR16 *LoadOptions, IN CONST CHAR16 *Loa
// // If there is no option to remove then duplicate original // // If there is no option to remove then duplicate original
// if (LoadOption.isEmpty()) return LoadOptions; // if (LoadOption.isEmpty()) return LoadOptions;
// // If not present duplicate original // // If not present duplicate original
// xsize Offset = LoadOptions.IdxOf(LoadOption); // xsize Offset = LoadOptions.indexOf(LoadOption);
// if ( Offset == MAX_XSIZE ) return LoadOptions; // if ( Offset == MAX_XSIZE ) return LoadOptions;
// //
// // Get placement of option in original options // // Get placement of option in original options

168
rEFIt_UEFI/cpp_unit_test/XString_test.cpp
View File

@ -24,9 +24,9 @@ struct make_unsigned
{ {
}; };
//template <> struct __make_unsigned<bool, true> {}; template <> struct make_unsigned< char> {typedef unsigned char type;};
template <> struct make_unsigned< signed char> {typedef unsigned short type;}; template <> struct make_unsigned< signed char> {typedef unsigned char type;};
template <> struct make_unsigned<unsigned char> {typedef unsigned short type;}; template <> struct make_unsigned<unsigned char> {typedef unsigned char type;};
template <> struct make_unsigned< signed short> {typedef unsigned short type;}; template <> struct make_unsigned< signed short> {typedef unsigned short type;};
template <> struct make_unsigned<unsigned short> {typedef unsigned short type;}; template <> struct make_unsigned<unsigned short> {typedef unsigned short type;};
template <> struct make_unsigned< signed int> {typedef unsigned int type;}; template <> struct make_unsigned< signed int> {typedef unsigned int type;};
@ -197,6 +197,7 @@ struct TestStringMultiCoded
const TestStringMultiCoded testStringMultiCodedArray[] = { const TestStringMultiCoded testStringMultiCodedArray[] = {
testStringArray_LINE(""), testStringArray_LINE(""),
testStringArray_LINE("a"), testStringArray_LINE("a"),
#ifndef _MSC_VER
testStringArray_LINE(utf8_1), testStringArray_LINE(utf8_1),
testStringArray_LINE(utf8_2), testStringArray_LINE(utf8_2),
testStringArray_LINE(utf8_3), testStringArray_LINE(utf8_3),
@ -208,6 +209,7 @@ const TestStringMultiCoded testStringMultiCodedArray[] = {
// testStringArray_LINE(utf8_9), // testStringArray_LINE(utf8_9),
// testStringArray_LINE(utf8_10), // testStringArray_LINE(utf8_10),
// testStringArray_LINE(utf8_11), // testStringArray_LINE(utf8_11),
#endif
}; };
size_t nbTestStringMultiCoded = *(&testStringMultiCodedArray + 1) - testStringMultiCodedArray; size_t nbTestStringMultiCoded = *(&testStringMultiCodedArray + 1) - testStringMultiCodedArray;
@ -400,12 +402,24 @@ bool displayOnlyIfFailed_tmp;
__TEST2(test, XStringClass, classEncoding, encoding1, utf32); \ __TEST2(test, XStringClass, classEncoding, encoding1, utf32); \
__TEST2(test, XStringClass, classEncoding, encoding1, wchar); \ __TEST2(test, XStringClass, classEncoding, encoding1, wchar); \
/* Warning about array indexes of char type is on, so don't test it
TODO disable warning with pragma and uncomment to test with char */
#define TEST_ALL_INTEGRAL(test, XStringClass, classEncoding) \ #define TEST_ALL_INTEGRAL(test, XStringClass, classEncoding) \
__TEST1(test, XStringClass, classEncoding, signed char); \ /*__TEST1(test, XStringClass, classEncoding, char);*/ \
__TEST1(test, XStringClass, classEncoding, unsigned char); \ /*__TEST1(test, XStringClass, classEncoding, signed char);*/ \
/*__TEST1(test, XStringClass, classEncoding, unsigned char);*/ \
__TEST1(test, XStringClass, classEncoding, short); \
__TEST1(test, XStringClass, classEncoding, signed short); \ __TEST1(test, XStringClass, classEncoding, signed short); \
__TEST1(test, XStringClass, classEncoding, unsigned short); \ __TEST1(test, XStringClass, classEncoding, unsigned short); \
__TEST1(test, XStringClass, classEncoding, int); \
__TEST1(test, XStringClass, classEncoding, signed int); \
__TEST1(test, XStringClass, classEncoding, unsigned int); \
__TEST1(test, XStringClass, classEncoding, long); \
__TEST1(test, XStringClass, classEncoding, signed long); \
__TEST1(test, XStringClass, classEncoding, unsigned long); \
__TEST1(test, XStringClass, classEncoding, long long); \
__TEST1(test, XStringClass, classEncoding, signed long long); \
__TEST1(test, XStringClass, classEncoding, unsigned long long); \
#define TEST_ALL_UTF(test, XStringClass, classEncoding) \ #define TEST_ALL_UTF(test, XStringClass, classEncoding) \
@ -585,9 +599,9 @@ SimpleString testEmpty_()
testEmpty_<XStringClass>(); \ testEmpty_<XStringClass>(); \
/***************************** char32At_u *****************************/ /***************************** char32At *****************************/
template<class XStringClass, typename integralType, class InitialValue> template<class XStringClass, typename integralType, class InitialValue>
SimpleString testchar32At_u_(const InitialValue& initialValue) SimpleString testchar32At_(const InitialValue& initialValue)
{ {
TEST_TITLE(displayOnlyFailed, sprintf("Test %s::char32At_u()", XStringClassInfo<XStringClass>::xStringClassName)); TEST_TITLE(displayOnlyFailed, sprintf("Test %s::char32At_u()", XStringClassInfo<XStringClass>::xStringClassName));
@ -603,13 +617,35 @@ SimpleString testchar32At_u_(const InitialValue& initialValue)
return SimpleString(); return SimpleString();
} }
#define testchar32At_u(XStringClass, classEncoding, integralType) \ #define testchar32At(XStringClass, classEncoding, integralType) \
printf("Test %s::testchar32At_u\n", STRINGIFY(XStringClass)); \ printf("Test %s::testchar32At\n", STRINGIFY(XStringClass)); \
for ( size_t i = 0 ; i < nbTestStringMultiCoded ; i++ ) { \ for ( size_t i = 0 ; i < nbTestStringMultiCoded ; i++ ) { \
testchar32At_u_<XStringClass, integralType>(testStringMultiCodedArray[i].classEncoding); \ testchar32At_<XStringClass, integralType>(testStringMultiCodedArray[i].classEncoding); \
} }
/***************************** dataSized *****************************/
template<class XStringClass, typename integralType>
SimpleString testdataSized_()
{
TEST_TITLE(displayOnlyFailed, sprintf("Test %s::dataSized()", XStringClassInfo<XStringClass>::xStringClassName));
XStringClass xstr;
integralType i = 10;
typename XStringClassInfo<XStringClass>::ch_t* s = xstr.dataSized(i);
(void)s;
CHECK_RESULT(xstr.allocatedSize() >= 10,
sprintf("xstr[i] == dst.cha[i] (%d)", 10),
sprintf("xstr[i] != dst.cha[i] (%zu!=%d)", xstr.allocatedSize(), 10)
);
return SimpleString();
}
#define testdataSized(XStringClass, classEncoding, integralType) \
printf("Test %s::testdataSized\n", STRINGIFY(XStringClass)); \
testdataSized_<XStringClass, integralType>(); \
/***************************** strcpy *****************************/ /***************************** strcpy *****************************/
@ -800,15 +836,15 @@ SimpleString teststrncat_(const InitialValue& initialValue, const ValueToCat& va
//xstr.takeValueFrom(initialValue.cha); //xstr.takeValueFrom(initialValue.cha);
//xstr.strncat(valueToCat.cha, i); //xstr.strncat(valueToCat.cha, i);
size_t expectedSize = (utf_size_of_utf_string(&c, initialValue.cha) + utf_size_of_utf_string_len(&c, valueToCat.cha, i))*sizeof(ch_t); size_t expectedSize = (utf_size_of_utf_string(&c, initialValue.cha) + utf_size_of_utf_string_len(&c, valueToCat.cha, i));
CHECK_RESULT(xstr.sizeInBytes() == expectedSize, CHECK_RESULT(xstr.sizeInBytes() == expectedSize * sizeof(ch_t),
sprintf("xstr.sizeInBytes() == expectedSize (%zu)", expectedSize), sprintf("xstr.sizeInBytes() == expectedSize (%zu)", expectedSize * sizeof(ch_t)),
sprintf("xstr.sizeInBytes() != expectedSize (%zu!=%zu)", xstr.sizeInBytes(), expectedSize) sprintf("xstr.sizeInBytes() != expectedSize (%zu!=%zu)", xstr.sizeInBytes(), expectedSize * sizeof(ch_t))
); );
ch_t* expectedString = (ch_t*)malloc(expectedSize*sizeof(ch_t)*sizeof(ch_t) + 1); ch_t* expectedString = (ch_t*)malloc((expectedSize+1)*sizeof(ch_t));
utf_string_from_utf_string(expectedString, expectedSize*sizeof(ch_t) + 1, initialValue.cha); utf_string_from_utf_string(expectedString, expectedSize + 1, initialValue.cha);
utf_string_from_utf_string_len(expectedString + utf_size_of_utf_string(&c, initialValue.cha), expectedSize*sizeof(ch_t) + 1 - size_of_utf_string(expectedString), valueToCat.cha, i); utf_string_from_utf_string_len(expectedString + utf_size_of_utf_string(&c, initialValue.cha), expectedSize + 1 - size_of_utf_string(expectedString), valueToCat.cha, i);
CHECK_RESULT(memcmp(xstr.s(), expectedString, expectedSize+sizeof(ch_t)) == 0, CHECK_RESULT(memcmp(xstr.s(), expectedString, expectedSize+sizeof(ch_t)) == 0,
sprintf("memcmp(xstr.s(), expectedString, dst.size) == 0"), sprintf("memcmp(xstr.s(), expectedString, dst.size) == 0"),
sprintf("memcmp(xstr.s(), expectedString, dst.size) != 0") sprintf("memcmp(xstr.s(), expectedString, dst.size) != 0")
@ -858,7 +894,7 @@ SimpleString testSubString_(const InitialValue& initialValue)
if ( pos < initialValue.utf32_length ) offset = utf_size_of_utf_string_len(&c, initialValue.cha, pos); if ( pos < initialValue.utf32_length ) offset = utf_size_of_utf_string_len(&c, initialValue.cha, pos);
else offset = utf_size_of_utf_string(&c, initialValue.cha); else offset = utf_size_of_utf_string(&c, initialValue.cha);
XStringClass subStr = str.SubString(pos, count); XStringClass subStr = str.subString(pos, count);
CHECK_RESULT(subStr.length() == expectedLength, CHECK_RESULT(subStr.length() == expectedLength,
sprintf("subStr.length() == expectedLength (%zu)", expectedLength), sprintf("subStr.length() == expectedLength (%zu)", expectedLength),
@ -1091,7 +1127,7 @@ SimpleString testCompare_(const InitialValue& initialValue)
/***************************** indexOf, rindexOf *****************************/ /***************************** indexOf, rindexOf *****************************/
template<class XStringClass, typename ch_t> template<class XStringClass, typename ch_t>
static void testIdxOf__(XStringClass subStr, bool ignoreCase, static void testindexOf__(XStringClass subStr, bool ignoreCase,
size_t (XStringClass::*indexOfChar)(char32_t, size_t) const, size_t (XStringClass::*indexOfChar)(char32_t, size_t) const,
size_t (XStringClass::*indexOfString)(const ch_t*, size_t) const, size_t (XStringClass::*indexOfString)(const ch_t*, size_t) const,
size_t (XStringClass::*rindexOfChar)(char32_t, size_t) const, size_t (XStringClass::*rindexOfChar)(char32_t, size_t) const,
@ -1103,14 +1139,14 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
testStr = subStr; testStr = subStr;
if ( ignoreCase ) testStr.lowerAscii(); if ( ignoreCase ) testStr.lowerAscii();
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 0, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 0,
sprintf("testStr.IdxOf(subStr.s(), 0) == 0"), sprintf("testStr.indexOf(subStr.s(), 0) == 0"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 0 (%zu)", (testStr.*indexOfString)(subStr.s(), 0)) sprintf("testStr.indexOf(subStr.s(), 0) != 0 (%zu)", (testStr.*indexOfString)(subStr.s(), 0))
); );
(testStr.*indexOfString)(subStr.s(), 0); (testStr.*indexOfString)(subStr.s(), 0);
size_t expectedPos = subStr.length()==0 ? testStr.length() : 0; size_t expectedPos = subStr.length()==0 ? testStr.length() : 0;
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == expectedPos, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == expectedPos,
sprintf("testStr.IdxOf(subStr.s(), 0) == expectedPos (%zu)", expectedPos), sprintf("testStr.indexOf(subStr.s(), 0) == expectedPos (%zu)", expectedPos),
sprintf("testStr.IdxOf(subStr.s(), 0) != 0 (%zu!=%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1), expectedPos) sprintf("testStr.indexOf(subStr.s(), 0) != 0 (%zu!=%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1), expectedPos)
); );
(testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1); (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1);
@ -1132,8 +1168,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
testStr.strcat(subStr.s()); testStr.strcat(subStr.s());
if ( ignoreCase ) testStr.lowerAscii(); if ( ignoreCase ) testStr.lowerAscii();
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 3, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 3,
sprintf("testStr.IdxOf(subStr.s(), 0) == 3"), sprintf("testStr.indexOf(subStr.s(), 0) == 3"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 3 (%zu)", (testStr.*indexOfString)(subStr.s(), 0)) sprintf("testStr.indexOf(subStr.s(), 0) != 3 (%zu)", (testStr.*indexOfString)(subStr.s(), 0))
); );
(testStr.*indexOfString)(subStr.s(), 0); (testStr.*indexOfString)(subStr.s(), 0);
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 3, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 3,
@ -1145,8 +1181,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
sprintf("(testStr.*indexOfString)(subStr[0]) != 3 (%zu)", (testStr.*indexOfChar)(subStr[0], 0)) sprintf("(testStr.*indexOfString)(subStr[0]) != 3 (%zu)", (testStr.*indexOfChar)(subStr[0], 0))
); );
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 3, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 3,
sprintf("testStr.IdxOf(subStr.s(), MAX_XSIZE-1) == 3"), sprintf("testStr.indexOf(subStr.s(), MAX_XSIZE-1) == 3"),
sprintf("testStr.IdxOf(subStr.s(), MAX_XSIZE-1) != 3 (%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1)) sprintf("testStr.indexOf(subStr.s(), MAX_XSIZE-1) != 3 (%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1))
); );
(testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1); (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1);
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 3, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 3,
@ -1163,8 +1199,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
testStr.strcat(""); testStr.strcat("");
if ( ignoreCase ) testStr.lowerAscii(); if ( ignoreCase ) testStr.lowerAscii();
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 4, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 4,
sprintf("testStr.IdxOf(subStr.s(), 0) == 4"), sprintf("testStr.indexOf(subStr.s(), 0) == 4"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 4 (%zu)", (testStr.*indexOfString)(subStr.s(), 0)) sprintf("testStr.indexOf(subStr.s(), 0) != 4 (%zu)", (testStr.*indexOfString)(subStr.s(), 0))
); );
(testStr.*indexOfString)(subStr.s(), 0); (testStr.*indexOfString)(subStr.s(), 0);
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 4, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 4,
@ -1176,8 +1212,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
sprintf("(testStr.*indexOfString)(subStr[0]) != 4 (%zu)", (testStr.*indexOfChar)(subStr[0], 0)) sprintf("(testStr.*indexOfString)(subStr[0]) != 4 (%zu)", (testStr.*indexOfChar)(subStr[0], 0))
); );
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 4, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 4,
sprintf("testStr.IdxOf(subStr.s(), 0) == 4"), sprintf("testStr.indexOf(subStr.s(), 0) == 4"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 4 (%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1)) sprintf("testStr.indexOf(subStr.s(), 0) != 4 (%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1))
); );
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 4, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 4,
sprintf("(testStr.*rindexOfString)(subStr.s(), 0) == 4"), sprintf("(testStr.*rindexOfString)(subStr.s(), 0) == 4"),
@ -1195,8 +1231,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
testStr.strcat(""); testStr.strcat("");
if ( ignoreCase ) testStr.lowerAscii(); if ( ignoreCase ) testStr.lowerAscii();
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 5, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 5,
sprintf("testStr.IdxOf(subStr.s(), 0) == 5"), sprintf("testStr.indexOf(subStr.s(), 0) == 5"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 5 (%zu)", (testStr.*indexOfString)(subStr.s(), 0)) sprintf("testStr.indexOf(subStr.s(), 0) != 5 (%zu)", (testStr.*indexOfString)(subStr.s(), 0))
); );
CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 5, CHECK_RESULT((testStr.*indexOfString)(subStr.s(), 0) == 5,
sprintf("(testStr.*indexOfString)(subStr.s(), 0) == 5"), sprintf("(testStr.*indexOfString)(subStr.s(), 0) == 5"),
@ -1207,8 +1243,8 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
sprintf("(testStr.*indexOfString)(subStr[0]) != 5 (%zu)", (testStr.*indexOfChar)(subStr[0], 0)) sprintf("(testStr.*indexOfString)(subStr[0]) != 5 (%zu)", (testStr.*indexOfChar)(subStr[0], 0))
); );
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 5 + subStr.length() + 6, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 5 + subStr.length() + 6,
sprintf("testStr.IdxOf(subStr.s(), 0) == 5 + subStr.length() + 6"), sprintf("testStr.indexOf(subStr.s(), 0) == 5 + subStr.length() + 6"),
sprintf("testStr.IdxOf(subStr.s(), 0) != 5 + subStr.length() + 6 (%zu!=%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1), 5 + subStr.length() + 6) sprintf("testStr.indexOf(subStr.s(), 0) != 5 + subStr.length() + 6 (%zu!=%zu)", (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1), 5 + subStr.length() + 6)
); );
(testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1); (testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1);
CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 5 + subStr.length() + 6, CHECK_RESULT((testStr.*rindexOfString)(subStr.s(), MAX_XSIZE-1) == 5 + subStr.length() + 6,
@ -1223,7 +1259,7 @@ static void testIdxOf__(XStringClass subStr, bool ignoreCase,
} }
template<class XStringClass, class InitialValue> template<class XStringClass, class InitialValue>
SimpleString testIdxOf_(const InitialValue& initialValue) SimpleString testindexOf_(const InitialValue& initialValue)
{ {
TEST_TITLE(displayOnlyFailed, sprintf("Test %s::idxOf", XStringClassInfo<XStringClass>::xStringClassName)); TEST_TITLE(displayOnlyFailed, sprintf("Test %s::idxOf", XStringClassInfo<XStringClass>::xStringClassName));
@ -1237,13 +1273,13 @@ SimpleString testIdxOf_(const InitialValue& initialValue)
for ( size_t pos = 0 ; pos < initialValue.utf32_length+3 ; pos+=1 ) { for ( size_t pos = 0 ; pos < initialValue.utf32_length+3 ; pos+=1 ) {
for ( size_t count = 0 ; count < initialValue.utf32_length-pos+3 ; count+=1 ) for ( size_t count = 0 ; count < initialValue.utf32_length-pos+3 ; count+=1 )
{ {
ixs_t subStr = str.SubString(pos, count); ixs_t subStr = str.subString(pos, count);
// size_t (ixs_t::*p)(const ich_t* S, size_t Pos) const = &ixs_t::template indexOf<ich_t>; // size_t (ixs_t::*p)(const ich_t* S, size_t Pos) const = &ixs_t::template indexOf<ich_t>;
testIdxOf__<ixs_t, ich_t>(subStr, false, &ixs_t::indexOf, &ixs_t::template indexOf, &ixs_t::rindexOf, &ixs_t::template rindexOf); testindexOf__<ixs_t, ich_t>(subStr, false, &ixs_t::indexOf, &ixs_t::template indexOf, &ixs_t::rindexOf, &ixs_t::template rindexOf);
ixs_t subStrLower = subStr; ixs_t subStrLower = subStr;
testIdxOf__<ixs_t, ich_t>(subStrLower, true, &ixs_t::indexOfIC, &ixs_t::template indexOfIC, &ixs_t::rindexOfIC, &ixs_t::template rindexOfIC); testindexOf__<ixs_t, ich_t>(subStrLower, true, &ixs_t::indexOfIC, &ixs_t::template indexOfIC, &ixs_t::rindexOfIC, &ixs_t::template rindexOfIC);
// if ( subStrLower != subStr ) { // if ( subStrLower != subStr ) {
// } // }
} }
@ -1252,13 +1288,13 @@ SimpleString testIdxOf_(const InitialValue& initialValue)
return SimpleString(); return SimpleString();
} }
#define testIdxOf(XStringClass, classEncoding, encoding) \ #define testindexOf(XStringClass, classEncoding, encoding) \
printf("Test %s::testIdxOf(%s)\n", STRINGIFY(XStringClass), STRINGIFY(encoding)); \ printf("Test %s::testindexOf(%s)\n", STRINGIFY(XStringClass), STRINGIFY(encoding)); \
for ( size_t i = 0 ; i < nbTestStringMultiCoded ; i++ ) { \ for ( size_t i = 0 ; i < nbTestStringMultiCoded ; i++ ) { \
testIdxOf_<XStringClass>(testStringMultiCodedArray[i].encoding); \ testindexOf_<XStringClass>(testStringMultiCodedArray[i].encoding); \
} \ } \
for ( size_t i = 0 ; i < nbTestStringMultiCoded4CaseArray ; i++ ) { \ for ( size_t i = 0 ; i < nbTestStringMultiCoded4CaseArray ; i++ ) { \
testIdxOf_<XStringClass>(testStringMultiCoded4CaseArray[i].encoding); \ testindexOf_<XStringClass>(testStringMultiCoded4CaseArray[i].encoding); \
} \ } \
@ -1278,7 +1314,7 @@ void func_test(XStringW& xsw)
(void)xsw; (void)xsw;
} }
int XStringx_tests() int XString_tests()
{ {
#ifdef JIEF_DEBUG #ifdef JIEF_DEBUG
// DebugLog(2, "XString16_tests -> Enter\n"); // DebugLog(2, "XString16_tests -> Enter\n");
@ -1288,15 +1324,21 @@ int XStringx_tests()
//const char* cc = " "; //const char* cc = " ";
//char buf[64]; //char buf[64];
//char16_t* buf16 = (char16_t*)u"foo16"; //char16_t* buf16 = (char16_t*)u"foo16";
XString x1; XString x1("a"_XS);
x1.takeValueFrom("a"); XString x2("b"_XS);
XString x2; XStringW xw1("c"_XS);
x2.takeValueFrom("b");
XStringW xw1; xw1.takeValueFrom("c"); char c = 1;
int ii = sizeof(size_t);
unsigned long long ull = SIZE_T_MAX;
unsigned long long ll = 3;
xw1.dataSized(c);
xw1.dataSized(ii);
xw1.dataSized(ull);
xw1.dataSized(ll);
auto x3 = xw1 = x1; //auto x3 = xw1 = x1;
func_test(x3); //func_test(x3);
// //
//XStringAbstract__is_char_st<decltype(buf16)> a; //XStringAbstract__is_char_st<decltype(buf16)> a;
//printf("a.v()=%d\n", a.v()); //printf("a.v()=%d\n", a.v());
@ -1313,22 +1355,34 @@ func_test(x3);
// testDefaultCtor<XString>("XString"); // testDefaultCtor<XString>("XString");
// XString16 a = u"toto"_XS16; // XString16 a = u"toto"_XS16;
// teststrncpy_<XString>("utf8", testStringMultiCodedArray[1].utf8, testStringMultiCodedArray[1].wchar); // teststrncpy_<XString>("utf8", testStringMultiCodedArray[1].utf8, testStringMultiCodedArray[1].wchar);
//testIdxOf(XString, utf8, utf16); //testindexOf(XString, utf8, utf16);
//testCompare(XString, utf8, utf8); //testCompare(XString, utf8, utf8);
testIdxOf_<XString>(testStringMultiCoded4CaseArray[0].utf8); \ //testindexOf_<XString>(testStringMultiCoded4CaseArray[0].utf8);
//size_t size = sizeof("ギ")-1; // this char is 6 bytes long ! const char* utf8 = "ギ"; (void)utf8;
size_t utf8_size = sizeof("ギ") - 1; (void)utf8_size; // this char is 6 bytes long !
const wchar_t* utfw = L"ギ"; (void)utfw;
size_t utfw_size = sizeof(L"ギ") - 1; (void)utfw_size; // this char is 6 bytes long !
const char16_t* utf16 = u"ギ"; (void)utf16;
size_t utf16_size = sizeof(u"ギ") - 1; (void)utf16_size; // this char is 6 bytes long !
const char32_t* utf32 = U"ギ"; (void)utf32;
size_t utf32_size = sizeof(U"ギ") - 1; (void)utf32_size; // this char is 6 bytes long !
//size_t size = sizeof("ꇉ")-1; // this char is 3 bytes long //size_t size = sizeof("ꇉ")-1; // this char is 3 bytes long
//size_t size = sizeof("伽")-1; // this char is 3 bytes long //size_t size = sizeof("伽")-1; // this char is 3 bytes long
//size_t size = sizeof("楘")-1; // this char is 3 bytes long //size_t size = sizeof("楘")-1; // this char is 3 bytes long
//XString str = "ギꇉ伽楘"_XS; //XString str = "ギꇉ伽楘"_XS;
//char* s = str.data(42); //char* s = str.data(42);
TEST_ALL_CLASSES(testchar32At, TEST_ALL_INTEGRAL);
TEST_ALL_CLASSES(testDefaultCtor, __TEST0); TEST_ALL_CLASSES(testDefaultCtor, __TEST0);
TEST_ALL_CLASSES(testEmpty, __TEST0); TEST_ALL_CLASSES(testEmpty, __TEST0);
TEST_ALL_CLASSES(testTakeValueFrom, TEST_ALL_UTF); TEST_ALL_CLASSES(testTakeValueFrom, TEST_ALL_UTF);
TEST_ALL_CLASSES(testTakeValueFromXString, TEST_ALL_UTF); TEST_ALL_CLASSES(testTakeValueFromXString, TEST_ALL_UTF);
TEST_ALL_CLASSES(testchar32At_u, TEST_ALL_INTEGRAL); TEST_ALL_CLASSES(testchar32At, TEST_ALL_INTEGRAL);
TEST_ALL_CLASSES(testdataSized, TEST_ALL_INTEGRAL);
TEST_ALL_CLASSES(teststrcpy, TEST_ALL_UTF); TEST_ALL_CLASSES(teststrcpy, TEST_ALL_UTF);
TEST_ALL_CLASSES(teststrncpy, TEST_ALL_UTF); // 26944 tests TEST_ALL_CLASSES(teststrncpy, TEST_ALL_UTF); // 26944 tests
@ -1337,7 +1391,7 @@ func_test(x3);
TEST_ALL_CLASSES(testSubString, __TEST0); TEST_ALL_CLASSES(testSubString, __TEST0);
TEST_ALL_CLASSES(testCompare, TEST_ALL_UTF); TEST_ALL_CLASSES(testCompare, TEST_ALL_UTF);
TEST_ALL_CLASSES(testIdxOf, TEST_ALL_UTF); TEST_ALL_CLASSES(testindexOf, TEST_ALL_UTF);

2
rEFIt_UEFI/cpp_unit_test/XString_test.h Normal file → Executable file
View File

@ -1 +1 @@
int XStringx_tests(); int XString_tests();

11
rEFIt_UEFI/cpp_unit_test/all_tests.cpp Normal file → Executable file
View File

@ -31,19 +31,18 @@ bool all_tests()
bool all_ok = true; bool all_ok = true;
int ret; int ret;
#ifdef XSTRING16_DEV ret = XString_tests();
ret = XStringx_tests();
if ( ret != 0 ) { if ( ret != 0 ) {
DebugLog(2, "XString16_tests() failed at test %d\n", ret); DebugLog(2, "XString16_tests() failed at test %d\n", ret);
all_ok = false; all_ok = false;
} }
return ret; //return ret;
// ret = XUINTN_tests(); // ret = XUINTN_tests();
// if ( ret != 0 ) { // if ( ret != 0 ) {
// DebugLog(2, "XUINTN_tests() failed at test %d\n", ret); // DebugLog(2, "XUINTN_tests() failed at test %d\n", ret);
// all_ok = false; // all_ok = false;
// } // }
#if defined(CLOVER_BUILD) #if defined(JIEF_DEBUG) && defined(CLOVER_BUILD)
ret = printlib_tests(); ret = printlib_tests();
if ( ret != 0 ) { if ( ret != 0 ) {
DebugLog(2, "printlib_tests() failed at test %d\n", ret); DebugLog(2, "printlib_tests() failed at test %d\n", ret);
@ -55,16 +54,12 @@ return ret;
all_ok = false; all_ok = false;
} }
#endif #endif
#endif
#ifndef _MSC_VER #ifndef _MSC_VER
ret = printf_lite_tests(); ret = printf_lite_tests();
if ( ret != 0 ) { if ( ret != 0 ) {
DebugLog(2, "printf_lite_tests() failed at test %d\n", ret); DebugLog(2, "printf_lite_tests() failed at test %d\n", ret);
all_ok = false; all_ok = false;
} }
#endif
#ifdef JIEF_DEBUG
//return ret;
#endif #endif
ret = strlen_tests(); ret = strlen_tests();
if ( ret != 0 ) { if ( ret != 0 ) {

15
rEFIt_UEFI/cpp_unit_test/printf_lite-test.cpp Normal file → Executable file
View File

@ -395,11 +395,18 @@ int printf_lite_tests(void)
#if __x86_64__ #if __x86_64__
#endif #endif
#ifdef SIZE_MAX
# define MY_SIZE_T_MAX SIZE_MAX
#elif defined(SIZE_T_MAX)
# define MY_SIZE_T_MAX SIZE_T_MAX
#elif
#warning No size_t max
#endif
size_t size; size_t size;
if ( SIZE_T_MAX == UINT64_MAX ) { if (MY_SIZE_T_MAX == UINT64_MAX ) {
size = SIZE_T_MAX; Test1arg(F("SIZE_MAX=18446744073709551615"), F("SIZE_MAX=%zu"), size); size = MY_SIZE_T_MAX; Test1arg(F("SIZE_MAX=18446744073709551615"), F("SIZE_MAX=%zu"), size);
}else if ( SIZE_T_MAX == UINT32_MAX ) { }else if (MY_SIZE_T_MAX == UINT32_MAX ) {
size = SIZE_T_MAX; Test1arg(F("SIZE_MAX=4294967295"), F("SIZE_MAX=%zu"), size); size = MY_SIZE_T_MAX; Test1arg(F("SIZE_MAX=4294967295"), F("SIZE_MAX=%zu"), size);
}else{ }else{
// 16 bits size_t ? Does that exist ? // 16 bits size_t ? Does that exist ?
} }

10
rEFIt_UEFI/entry_scan/common.cpp
View File

@ -131,7 +131,7 @@ XString AddLoadOption(IN CONST XString& LoadOptions, IN CONST XString& LoadOptio
} }
// If there is no option or it is already present duplicate original // If there is no option or it is already present duplicate original
else { else {
if ( LoadOptions.ExistIn(LoadOption) ) return LoadOptions; //good if ( LoadOptions.contains(LoadOption) ) return LoadOptions; //good
// Otherwise add option // Otherwise add option
// return SPrintf("%s %s", LoadOptions.c_str(), LoadOption.c_str()); //LoadOptions + LoadOption // return SPrintf("%s %s", LoadOptions.c_str(), LoadOption.c_str()); //LoadOptions + LoadOption
return LoadOptions + " "_XS + LoadOption; //why not? return LoadOptions + " "_XS + LoadOption; //why not?
@ -150,7 +150,7 @@ XString RemoveLoadOption(IN const XString& LoadOptions, IN const XString& LoadOp
// If there is no option to remove then duplicate original // If there is no option to remove then duplicate original
if (LoadOption.isEmpty()) return LoadOptions; if (LoadOption.isEmpty()) return LoadOptions;
// If not present duplicate original // If not present duplicate original
xsize Offset = LoadOptions.IdxOf(LoadOption); xsize Offset = LoadOptions.indexOf(LoadOption);
if ( Offset == MAX_XSIZE ) return LoadOptions; if ( Offset == MAX_XSIZE ) return LoadOptions;
// Get placement of option in original options // Get placement of option in original options
@ -181,15 +181,15 @@ XString RemoveLoadOption(IN const XString& LoadOptions, IN const XString& LoadOp
XString NewLoadOptions; XString NewLoadOptions;
if (Offset == 0) { if (Offset == 0) {
// Simple case - we just need substring after OptionLength position // Simple case - we just need substring after OptionLength position
NewLoadOptions = LoadOptions.SubString(OptionLength, MAX_XSIZE); NewLoadOptions = LoadOptions.subString(OptionLength, MAX_XSIZE);
} else { } else {
// Copy preceeding substring // Copy preceeding substring
NewLoadOptions = LoadOptions.SubString(0, Offset); NewLoadOptions = LoadOptions.subString(0, Offset);
// CopyMem(NewLoadOptions, LoadOptions, Offset * sizeof(CHAR16)); // CopyMem(NewLoadOptions, LoadOptions, Offset * sizeof(CHAR16));
if ((Offset + OptionLength) < Length) { if ((Offset + OptionLength) < Length) {
// Copy following substring, but include one space also // Copy following substring, but include one space also
OptionLength--; OptionLength--;
NewLoadOptions += LoadOptions.SubString(Offset + OptionLength, MAX_XSIZE); NewLoadOptions += LoadOptions.subString(Offset + OptionLength, MAX_XSIZE);
// CopyMem(NewLoadOptions + Offset, LoadOptions + Offset + OptionLength, (Length - OptionLength - Offset) * sizeof(CHAR16)); // CopyMem(NewLoadOptions + Offset, LoadOptions + Offset + OptionLength, (Length - OptionLength - Offset) * sizeof(CHAR16));
} }
} }

14
rEFIt_UEFI/entry_scan/loader.cpp
View File

@ -251,7 +251,7 @@ UINT8 GetOSTypeFromPath(IN CONST CHAR16 *Path)
// (StriCmp(Path, L"\\bootmgr.efi") == 0) || //never worked, just extra icon in menu // (StriCmp(Path, L"\\bootmgr.efi") == 0) || //never worked, just extra icon in menu
(StriCmp(Path, L"\\EFI\\MICROSOFT\\BOOT\\cdboot.efi") == 0)) { (StriCmp(Path, L"\\EFI\\MICROSOFT\\BOOT\\cdboot.efi") == 0)) {
return OSTYPE_WINEFI; return OSTYPE_WINEFI;
} else if (LINUX_FULL_LOADER_PATH.EqualIC(Path)) { } else if (LINUX_FULL_LOADER_PATH.equalIC(Path)) {
return OSTYPE_LINEFI; return OSTYPE_LINEFI;
} else if (StriStr(Path, L"grubx64.efi") != NULL) { } else if (StriStr(Path, L"grubx64.efi") != NULL) {
return OSTYPE_LINEFI; return OSTYPE_LINEFI;
@ -301,7 +301,7 @@ STATIC CONST CHAR16 *LinuxIconNameFromPath(IN CONST CHAR16 *Path,
} }
// Try to open the linux issue // Try to open the linux issue
if ((RootDir != NULL) && LINUX_FULL_LOADER_PATH.EqualIC(Path)) { if ((RootDir != NULL) && LINUX_FULL_LOADER_PATH.equalIC(Path)) {
CHAR8 *Issue = NULL; CHAR8 *Issue = NULL;
UINTN IssueLen = 0; UINTN IssueLen = 0;
if (!EFI_ERROR(egLoadFile(RootDir, LINUX_ISSUE_PATH.wc_str(), (UINT8 **)&Issue, &IssueLen)) && (Issue != NULL)) { if (!EFI_ERROR(egLoadFile(RootDir, LINUX_ISSUE_PATH.wc_str(), (UINT8 **)&Issue, &IssueLen)) && (Issue != NULL)) {
@ -605,7 +605,7 @@ STATIC LOADER_ENTRY *CreateLoaderEntry(IN CONST CHAR16 *LoaderPath,
case OSTYPE_OSX_INSTALLER: case OSTYPE_OSX_INSTALLER:
OSIconName = GetOSIconName(Entry->OSVersion);// Sothor - Get OSIcon name using OSVersion OSIconName = GetOSIconName(Entry->OSVersion);// Sothor - Get OSIcon name using OSVersion
// apianti - force custom logo even when verbose // apianti - force custom logo even when verbose
if ( Entry->LoadOptions.ExistInIC("-v") ) { if ( Entry->LoadOptions.containsIC("-v") ) {
// OSX is not booting verbose, so we can set console to graphics mode // OSX is not booting verbose, so we can set console to graphics mode
Entry->Flags = OSFLAG_UNSET(Entry->Flags, OSFLAG_USEGRAPHICS); Entry->Flags = OSFLAG_UNSET(Entry->Flags, OSFLAG_USEGRAPHICS);
} }
@ -891,8 +891,8 @@ STATIC VOID AddDefaultMenu(IN LOADER_ENTRY *Entry)
} }
} else if (Entry->LoaderType == OSTYPE_LINEFI) { } else if (Entry->LoaderType == OSTYPE_LINEFI) {
BOOLEAN Quiet = Entry->LoadOptions.ExistIn("quiet"); BOOLEAN Quiet = Entry->LoadOptions.contains("quiet");
BOOLEAN WithSplash = Entry->LoadOptions.ExistIn("splash"); BOOLEAN WithSplash = Entry->LoadOptions.contains("splash");
// default entry // default entry
SubEntry = Entry->getPartiallyDuplicatedEntry(); SubEntry = Entry->getPartiallyDuplicatedEntry();
@ -1233,7 +1233,7 @@ VOID ScanLoader(VOID)
if (aFound && (aFound == aIndex)) { if (aFound && (aFound == aIndex)) {
XImage ImageX; XImage ImageX;
XStringW IconXSW = XStringW().takeValueFrom(AndroidEntryData[Index].Icon); XStringW IconXSW = XStringW().takeValueFrom(AndroidEntryData[Index].Icon);
ImageX.LoadXImage(ThemeX.ThemeDir, (L"os_"_XSW + IconXSW.SubString(0, IconXSW.IdxOf(','))).wc_str()); ImageX.LoadXImage(ThemeX.ThemeDir, (L"os_"_XSW + IconXSW.subString(0, IconXSW.indexOf(','))).wc_str());
AddLoaderEntry(AndroidEntryData[Index].Path, ""_XS, XStringW().takeValueFrom(AndroidEntryData[Index].Title), Volume, AddLoaderEntry(AndroidEntryData[Index].Path, ""_XS, XStringW().takeValueFrom(AndroidEntryData[Index].Title), Volume,
(ImageX.isEmpty() ? NULL : &ImageX), OSTYPE_LIN, OSFLAG_NODEFAULTARGS); (ImageX.isEmpty() ? NULL : &ImageX), OSTYPE_LIN, OSFLAG_NODEFAULTARGS);
} }
@ -1273,7 +1273,7 @@ VOID ScanLoader(VOID)
if (FileExists(Volume->RootDir, LinuxEntryData[Index].Path)) { if (FileExists(Volume->RootDir, LinuxEntryData[Index].Path)) {
XImage ImageX; XImage ImageX;
XStringW IconXSW = XStringW().takeValueFrom(LinuxEntryData[Index].Icon); XStringW IconXSW = XStringW().takeValueFrom(LinuxEntryData[Index].Icon);
ImageX.LoadXImage(ThemeX.ThemeDir, (L"os_"_XSW + IconXSW.SubString(0, IconXSW.IdxOf(','))).wc_str()); ImageX.LoadXImage(ThemeX.ThemeDir, (L"os_"_XSW + IconXSW.subString(0, IconXSW.indexOf(','))).wc_str());
AddLoaderEntry(LinuxEntryData[Index].Path, ""_XS, XStringW().takeValueFrom(LinuxEntryData[Index].Title), Volume, AddLoaderEntry(LinuxEntryData[Index].Path, ""_XS, XStringW().takeValueFrom(LinuxEntryData[Index].Title), Volume,
(ImageX.isEmpty() ? NULL : &ImageX), OSTYPE_LIN, OSFLAG_NODEFAULTARGS); (ImageX.isEmpty() ? NULL : &ImageX), OSTYPE_LIN, OSFLAG_NODEFAULTARGS);
} }

2
rEFIt_UEFI/gui/shared_with_menu.cpp
View File

@ -79,7 +79,7 @@ UINT32 EncodeOptions(const XString& Options)
return 0; return 0;
} }
for (Index = 0; Index < NUM_OPT; Index++) { for (Index = 0; Index < NUM_OPT; Index++) {
if ( Options.ExistIn(ArgOptional[Index]) ) { if ( Options.contains(ArgOptional[Index]) ) {
OptionsBits |= (1 << Index); OptionsBits |= (1 << Index);
if (Index == 1) { if (Index == 1) {
OptionsBits &= ~1; OptionsBits &= ~1;

12
rEFIt_UEFI/libeg/VectorGraphics.cpp
View File

@ -91,11 +91,11 @@ EFI_STATUS XTheme::ParseSVGXIcon(INTN Id, const XString& IconNameX, XImage* Imag
// if (BootCampStyle && (strstr(IconName, "selection_big") != NULL)) { // if (BootCampStyle && (strstr(IconName, "selection_big") != NULL)) {
// shape->opacity = 0.f; // shape->opacity = 0.f;
// } // }
if (BootCampStyle && IconNameX.ExistIn("selection_big")) { if (BootCampStyle && IconNameX.contains("selection_big")) {
shape->opacity = 0.f; shape->opacity = 0.f;
} }
// if (strstr(shape->id, "BoundingRect") != NULL) { // if (strstr(shape->id, "BoundingRect") != NULL) {
if (XString().takeValueFrom(shape->id).ExistIn("BoundingRect")) { if (XString().takeValueFrom(shape->id).contains("BoundingRect")) {
//there is bounds after nsvgParse() //there is bounds after nsvgParse()
IconImage->width = shape->bounds[2] - shape->bounds[0]; IconImage->width = shape->bounds[2] - shape->bounds[0];
IconImage->height = shape->bounds[3] - shape->bounds[1]; IconImage->height = shape->bounds[3] - shape->bounds[1];
@ -103,12 +103,12 @@ EFI_STATUS XTheme::ParseSVGXIcon(INTN Id, const XString& IconNameX, XImage* Imag
if ( IconImage->height < 1.f ) { if ( IconImage->height < 1.f ) {
IconImage->height = 200.f; IconImage->height = 200.f;
} }
if (IconNameX.ExistIn("selection_big") && (!SelectionOnTop)) { if (IconNameX.contains("selection_big") && (!SelectionOnTop)) {
MainEntriesSize = (int)(IconImage->width * Scale); //xxx MainEntriesSize = (int)(IconImage->width * Scale); //xxx
row0TileSize = MainEntriesSize + (int)(16.f * Scale); row0TileSize = MainEntriesSize + (int)(16.f * Scale);
DBG("main entry size = %lld\n", MainEntriesSize); DBG("main entry size = %lld\n", MainEntriesSize);
} }
if (IconNameX.ExistIn("selection_small") && (!SelectionOnTop)) { if (IconNameX.contains("selection_small") && (!SelectionOnTop)) {
row1TileSize = (int)(IconImage->width * Scale); row1TileSize = (int)(IconImage->width * Scale);
} }
@ -185,7 +185,7 @@ EFI_STATUS XTheme::ParseSVGXIcon(INTN Id, const XString& IconNameX, XImage* Imag
bounds[3] = -FLT_MAX; bounds[3] = -FLT_MAX;
nsvg__imageBounds(p2, bounds); nsvg__imageBounds(p2, bounds);
CopyMem(IconImage->realBounds, bounds, 4 * sizeof(float)); CopyMem(IconImage->realBounds, bounds, 4 * sizeof(float));
if ((Id == BUILTIN_ICON_BANNER) && IconNameX.ExistIn("Banner")) { if ((Id == BUILTIN_ICON_BANNER) && IconNameX.contains("Banner")) {
BannerPosX = (int)(bounds[0] * Scale - CentreShift); BannerPosX = (int)(bounds[0] * Scale - CentreShift);
if (BannerPosX < 0) { if (BannerPosX < 0) {
BannerPosX = 1; //one pixel BannerPosX = 1; //one pixel
@ -211,7 +211,7 @@ EFI_STATUS XTheme::ParseSVGXIcon(INTN Id, const XString& IconNameX, XImage* Imag
float tx = 0.f, ty = 0.f; float tx = 0.f, ty = 0.f;
if ((Id != BUILTIN_ICON_BACKGROUND) && if ((Id != BUILTIN_ICON_BACKGROUND) &&
(Id != BUILTIN_ICON_ANIME) && (Id != BUILTIN_ICON_ANIME) &&
!IconNameX.ExistIn("Banner")) { !IconNameX.contains("Banner")) {
float realWidth = (bounds[2] - bounds[0]) * Scale; float realWidth = (bounds[2] - bounds[0]) * Scale;
float realHeight = (bounds[3] - bounds[1]) * Scale; float realHeight = (bounds[3] - bounds[1]) * Scale;
// DBG("icon=%s width=%f realwidth=%f\n", IconNameX.c_str(), Width, realWidth); // DBG("icon=%s width=%f realwidth=%f\n", IconNameX.c_str(), Width, realWidth);

12
rEFIt_UEFI/libeg/XTheme.cpp
View File

@ -395,26 +395,26 @@ const XImage& XTheme::LoadOSIcon(const XString& Full)
XString Second; XString Second;
XString Third; XString Third;
const XImage *ReturnImage; const XImage *ReturnImage;
UINTN Comma = Full.IdxOf(','); UINTN Comma = Full.indexOf(',');
UINTN Size = Full.length(); UINTN Size = Full.length();
// DBG("IconName=%ls comma=%lld size=%lld\n", OSIconName, Comma, Size); // DBG("IconName=%ls comma=%lld size=%lld\n", OSIconName, Comma, Size);
if (Comma != MAX_XSIZE) { //Comma if (Comma != MAX_XSIZE) { //Comma
First = "os_"_XS + Full.SubString(0, Comma); First = "os_"_XS + Full.subString(0, Comma);
ReturnImage = &GetIcon(First); ReturnImage = &GetIcon(First);
// DBG(" first=%s\n", First.c_str()); // DBG(" first=%s\n", First.c_str());
if (!ReturnImage->isEmpty()) return *ReturnImage; if (!ReturnImage->isEmpty()) return *ReturnImage;
//else search second name //else search second name
Second = "os_"_XS + Full.SubString(Comma + 1, Size - Comma - 1); Second = "os_"_XS + Full.subString(Comma + 1, Size - Comma - 1);
//moreover names can be triple L"chrome,grub,linux" //moreover names can be triple L"chrome,grub,linux"
UINTN SecondComma = Second.IdxOf(','); UINTN SecondComma = Second.indexOf(',');
if (Comma == MAX_XSIZE) { if (Comma == MAX_XSIZE) {
ReturnImage = &GetIcon(Second); ReturnImage = &GetIcon(Second);
if (!ReturnImage->isEmpty()) return *ReturnImage; if (!ReturnImage->isEmpty()) return *ReturnImage;
} else { } else {
First = Second.SubString(0, SecondComma); First = Second.subString(0, SecondComma);
ReturnImage = &GetIcon(First); ReturnImage = &GetIcon(First);
if (!ReturnImage->isEmpty()) return *ReturnImage; if (!ReturnImage->isEmpty()) return *ReturnImage;
Third = "os_"_XS + Second.SubString(SecondComma + 1, Size - SecondComma - 1); Third = "os_"_XS + Second.subString(SecondComma + 1, Size - SecondComma - 1);
ReturnImage = &GetIcon(Third); ReturnImage = &GetIcon(Third);
if (!ReturnImage->isEmpty()) return *ReturnImage; if (!ReturnImage->isEmpty()) return *ReturnImage;
} }

16
rEFIt_UEFI/refit/main.cpp
View File

@ -749,7 +749,7 @@ static VOID StartLoader(IN LOADER_ENTRY *Entry)
} }
// Set boot argument for kernel if no caches, this should force kernel loading // Set boot argument for kernel if no caches, this should force kernel loading
if ( OSFLAG_ISSET(Entry->Flags, OSFLAG_NOCACHES) && !Entry->LoadOptions.ExistInIC("Kernel="_XS) ) { if ( OSFLAG_ISSET(Entry->Flags, OSFLAG_NOCACHES) && !Entry->LoadOptions.containsIC("Kernel="_XS) ) {
XString KernelLocation; XString KernelLocation;
if (Entry->OSVersion && AsciiOSVersionToUint64(Entry->OSVersion) <= AsciiOSVersionToUint64("10.9")) { if (Entry->OSVersion && AsciiOSVersionToUint64(Entry->OSVersion) <= AsciiOSVersionToUint64("10.9")) {
@ -802,7 +802,7 @@ static VOID StartLoader(IN LOADER_ENTRY *Entry)
if ( gDriversFlags.AptioFixLoaded && if ( gDriversFlags.AptioFixLoaded &&
!DoHibernateWake && !DoHibernateWake &&
!Entry->LoadOptions.ExistIn("slide=") ) { !Entry->LoadOptions.contains("slide=") ) {
// Add slide=0 argument for ML+ if not present // Add slide=0 argument for ML+ if not present
Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "slide=0"_XS); Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "slide=0"_XS);
} }
@ -816,7 +816,7 @@ static VOID StartLoader(IN LOADER_ENTRY *Entry)
(AsciiStrStr(gCPUStructure.BrandString, "Celeron") || AsciiStrStr(gCPUStructure.BrandString, "Pentium")) && (AsciiStrStr(gCPUStructure.BrandString, "Celeron") || AsciiStrStr(gCPUStructure.BrandString, "Pentium")) &&
(AsciiOSVersionToUint64(Entry->OSVersion) >= AsciiOSVersionToUint64("10.8.5")) && (AsciiOSVersionToUint64(Entry->OSVersion) >= AsciiOSVersionToUint64("10.8.5")) &&
(AsciiOSVersionToUint64(Entry->OSVersion) < AsciiOSVersionToUint64("10.12")) && (AsciiOSVersionToUint64(Entry->OSVersion) < AsciiOSVersionToUint64("10.12")) &&
(!Entry->LoadOptions.ExistIn("-xcpm"_XS))) { (!Entry->LoadOptions.contains("-xcpm"_XS))) {
// add "-xcpm" argv if not present on Haswell+ Celeron/Pentium // add "-xcpm" argv if not present on Haswell+ Celeron/Pentium
Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "-xcpm"_XS); Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "-xcpm"_XS);
} }
@ -826,7 +826,7 @@ static VOID StartLoader(IN LOADER_ENTRY *Entry)
gCPUStructure.Model == CPU_MODEL_IVY_BRIDGE && gCPUStructure.Model == CPU_MODEL_IVY_BRIDGE &&
(AsciiOSVersionToUint64(Entry->OSVersion) >= AsciiOSVersionToUint64("10.8.5")) && (AsciiOSVersionToUint64(Entry->OSVersion) >= AsciiOSVersionToUint64("10.8.5")) &&
(AsciiOSVersionToUint64(Entry->OSVersion) < AsciiOSVersionToUint64("10.12")) && (AsciiOSVersionToUint64(Entry->OSVersion) < AsciiOSVersionToUint64("10.12")) &&
(!Entry->LoadOptions.ExistIn("-xcpm"))) { (!Entry->LoadOptions.contains("-xcpm"))) {
// add "-xcpm" argv if not present on Ivy Bridge // add "-xcpm" argv if not present on Ivy Bridge
Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "-xcpm"_XS); Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, "-xcpm"_XS);
} }
@ -848,7 +848,7 @@ static VOID StartLoader(IN LOADER_ENTRY *Entry)
// which is wrong // which is wrong
// apianti - only block console output if using graphics // apianti - only block console output if using graphics
// but don't block custom boot logo // but don't block custom boot logo
if ( Entry->LoadOptions.ExistInIC("-v"_XS) ) { if ( Entry->LoadOptions.containsIC("-v"_XS) ) {
Entry->Flags = OSFLAG_UNSET(Entry->Flags, OSFLAG_USEGRAPHICS); Entry->Flags = OSFLAG_UNSET(Entry->Flags, OSFLAG_USEGRAPHICS);
} else if ( Entry->LoadOptions.isEmpty() ) { } else if ( Entry->LoadOptions.isEmpty() ) {
Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, " "_XS); Entry->LoadOptions = AddLoadOption(Entry->LoadOptions, " "_XS);
@ -2718,7 +2718,7 @@ RefitMain (IN EFI_HANDLE ImageHandle,
gEmuVariableControl->UninstallEmulation(gEmuVariableControl); gEmuVariableControl->UninstallEmulation(gEmuVariableControl);
} }
*/ */
if ( LoaderEntry->LoadOptions.ExistIn("BO-ADD") ) { if ( LoaderEntry->LoadOptions.contains("BO-ADD") ) {
CHAR16 *Description; CHAR16 *Description;
CONST CHAR16 *VolName; CONST CHAR16 *VolName;
CONST CHAR16 *LoaderName; CONST CHAR16 *LoaderName;
@ -2787,13 +2787,13 @@ RefitMain (IN EFI_HANDLE ImageHandle,
PrintBootOptions(FALSE); PrintBootOptions(FALSE);
} else if ( LoaderEntry->LoadOptions.ExistIn("BO-REMOVE") ) { } else if ( LoaderEntry->LoadOptions.contains("BO-REMOVE") ) {
PrintBootOptions(FALSE); PrintBootOptions(FALSE);
Status = DeleteBootOptionForFile (LoaderEntry->Volume->DeviceHandle, Status = DeleteBootOptionForFile (LoaderEntry->Volume->DeviceHandle,
LoaderEntry->LoaderPath LoaderEntry->LoaderPath
); );
PrintBootOptions(FALSE); PrintBootOptions(FALSE);
} else if ( LoaderEntry->LoadOptions.ExistIn("BO-PRINT") ) { } else if ( LoaderEntry->LoadOptions.contains("BO-PRINT") ) {
PrintBootOptions(TRUE); PrintBootOptions(TRUE);
} }