mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-25 16:37:42 +01:00
330 lines
16 KiB
C++
Executable File
330 lines
16 KiB
C++
Executable File
//*************************************************************************************************
|
|
//*************************************************************************************************
|
|
//
|
|
// STRING
|
|
//
|
|
//*************************************************************************************************
|
|
//*************************************************************************************************
|
|
|
|
#if !defined(__XSTRING_H__)
|
|
#define __XSTRING_H__
|
|
|
|
#include "XToolsCommon.h"
|
|
|
|
#define PATH_SEPARATOR '\\'
|
|
|
|
extern UINTN XStringGrowByDefault;
|
|
|
|
|
|
//class XConstString;
|
|
class XStringW;
|
|
|
|
class XString
|
|
{
|
|
protected:
|
|
char *m_data;
|
|
xsize m_allocatedSize;
|
|
|
|
// convenience method. Did it this way to avoid #define in header. They can have an impact on other headers
|
|
xsize min(xsize x1, xsize x2) const { if ( x1 < x2 ) return x1; return x2; }
|
|
xsize max(xsize x1, xsize x2) const { if ( x1 > x2 ) return x1; return x2; }
|
|
|
|
// Next 2 methods are protected intentionally. They are const method returning non-const pointer. That's intentional, but dangerous. Do not expose to public.
|
|
// It's better practice, if you need a non-const pointer for low-level access, to use dataSized and ahev to specify the size
|
|
// It's possible to access data(m_allocatedSize) because the real allocated size is m_allocatedSize+1
|
|
char* _data(unsigned int ui) const { if ( ui > m_allocatedSize ) panic("char* data(unsigned int ui=0) -> ui > m_allocatedSize"); return m_data+ui; }
|
|
char* _data(int i) const { if ( i<0 ) panic("char* data(int i) -> i < 0"); if ( (unsigned int)i > m_allocatedSize ) panic("char* data(int i) -> i > m_allocatedSize"); return m_data+i; }
|
|
char* _data(unsigned long ui) const { if ( ui > m_allocatedSize ) panic("char* data(unsigned long ui=0) -> ui > m_allocatedSize"); return m_data+ui; }
|
|
char* _data(long i) const { if ( i<0 ) panic("char* data(long i) -> i < 0"); if ( (unsigned long)i > m_allocatedSize ) panic("char* data(long i) -> i > m_allocatedSize"); return m_data+i; }
|
|
char* _data(xsize ui) const { if ( ui > m_allocatedSize ) panic("char* data(xsize ui=0) -> ui > m_allocatedSize"); return m_data+ui; }
|
|
char* _data(xisize i) const { if ( i<0 ) panic("char* data(xisize i) -> i < 0"); if ( (xsize)i > m_allocatedSize ) panic("char* data(xisize i) -> i > m_allocatedSize"); return m_data+i; }
|
|
|
|
public:
|
|
|
|
void Init(xsize aSize=0);
|
|
XString();
|
|
XString(const XString &aString);
|
|
XString(XString&& aString); // Move constructor
|
|
|
|
|
|
// XString(const XConstString &aConstString);
|
|
// XString(const char *S);
|
|
// XString(const char* S, xsize count);
|
|
|
|
// XString(const wchar_t *S);
|
|
|
|
// XString(uchar);
|
|
// XString(char);
|
|
// XString(int);
|
|
// XString(unsigned long long);
|
|
|
|
~XString();
|
|
|
|
public:
|
|
char *CheckSize(xsize nNewSize, xsize nGrowBy = XStringGrowByDefault);
|
|
|
|
public:
|
|
const char* c_str() const { return m_data; } // same as std::string
|
|
const char* data(xsize ui=0) const { return _data(ui); }
|
|
const char* data(xisize i) const { return _data(i); }
|
|
|
|
char* dataSized(xsize ui, xsize sizeMin, xsize nGrowBy=XStringGrowByDefault) { CheckSize(ui+sizeMin, nGrowBy); return _data(ui); }
|
|
|
|
xsize length() const { return strlen(m_data); }
|
|
xsize size() const { return strlen(m_data); }
|
|
xsize allocatedSize() const { return m_allocatedSize; }
|
|
void setLength(xsize len);
|
|
|
|
/* IsNull ? */
|
|
void setEmpty() { setLength(0); }
|
|
bool isEmpty() const { return length() == 0; }
|
|
bool notEmpty() const { return !isEmpty(); }
|
|
|
|
/* Cast */
|
|
// operator const char *() const { return data(); } // disabled during big refactoring
|
|
// operator char *() { return data(); }
|
|
|
|
// int ToInt() const;
|
|
// UINTN ToUINTN() const;
|
|
|
|
/* char [] */
|
|
char operator [](int i) const { return *_data(i); }
|
|
char operator [](unsigned int ui) const { return *_data(ui); }
|
|
char operator [](long i) const { return *_data(i); }
|
|
char operator [](unsigned long ui) const { return *_data(ui); }
|
|
char operator [](xisize i) const { return *data(i); }
|
|
char operator [](xsize ui) const { return *data(ui); }
|
|
|
|
/* char& [] */
|
|
char& operator [](int i) { return *_data(i); }
|
|
char& operator [](unsigned int ui) { return *_data(ui); }
|
|
char& operator [](long i) { return *_data(i); }
|
|
char& operator [](unsigned long ui) { return *_data(ui); }
|
|
char& operator [](xisize i) { return *_data(i); }
|
|
char& operator [](xsize ui) { return *_data(ui); }
|
|
|
|
char lastChar() const { if ( length() > 0 ) return data()[length()-1]; else return 0; }
|
|
void removeLastEspCtrl();
|
|
|
|
void StrCpy(const char *buf);
|
|
void StrnCpy(const char *buf, xsize len);
|
|
void StrnCat(const char *buf, xsize len);
|
|
void StrCat(const char *buf);
|
|
void StrCat(const XString& S) { StrCat(S.c_str()) ; }
|
|
void Delete(xsize pos, xsize count=1);
|
|
|
|
void Insert(xsize pos, const XString& Str);
|
|
|
|
void Cat(const XString &uneXString);
|
|
|
|
XString& vSPrintf(const char *Format, va_list va);
|
|
XString& SPrintf(const char *format, ...) __attribute__((format (printf, 2, 3))); // 2 and 3 because of hidden parameter 'this'.
|
|
|
|
const XString& takeValueFrom(const char* S) { StrCpy(S); return *this; }
|
|
const XString& takeValueFrom(const char* S, xsize count) { StrnCpy(S, count); return *this; }
|
|
const XString& takeValueFrom(const wchar_t* S) { SPrintf("%ls", S); return *this; }
|
|
|
|
const XString& operator =(const XString& aString);
|
|
XString& operator =(XString&& aString);
|
|
// const XString &operator =(const XConstString &aConstString);
|
|
|
|
// Deactivate assignment during refactoring to avoid confusion
|
|
// const XString &operator =(const char* S);
|
|
// const XString &operator =(char);
|
|
// const XString &operator =(int);
|
|
// const XString &operator =(unsigned int);
|
|
// const XString &operator =(long);
|
|
// const XString &operator =(unsigned long long);
|
|
|
|
const XString &operator += (const XString &);
|
|
const XString &operator += (const char* S);
|
|
// const XString &operator += (const XConstString &aConstString);
|
|
|
|
// Deactivate assignment during refactoring to avoid confusion
|
|
// const XString &operator += (char);
|
|
// const XString &operator += (int);
|
|
// const XString &operator += (unsigned int);
|
|
// const XString &operator += (long);
|
|
// const XString &operator += (unsigned long long);
|
|
|
|
XString SubString(xsize pos, xsize count) const;
|
|
|
|
xsize IdxOf(char c, xsize Pos = 0) const;
|
|
|
|
xsize IdxOf(const char* s, xsize s_len, xsize pos) const;
|
|
xsize IdxOf(const char* s, xsize pos = 0) const { return IdxOf(s, strlen(s), pos); }
|
|
xsize IdxOf(const XString &S, xsize pos = 0) const { return IdxOf(S.c_str(), S.length(), pos); }
|
|
bool ExistIn(const char* s, xsize s_len, xsize pos = 0) const { return IdxOf(s, s_len, pos) != MAX_XSIZE; }
|
|
bool ExistIn(const char* s, xsize pos = 0) const { return IdxOf(s, pos) != MAX_XSIZE; }
|
|
bool ExistIn(const XString &S, xsize pos = 0) const { return IdxOf(S, pos) != MAX_XSIZE; }
|
|
|
|
xsize IdxOfIC(const char* s, xsize s_len, xsize pos) const;
|
|
xsize IdxOfIC(const char* s, xsize pos = 0) const { return IdxOfIC(s, strlen(s), pos); }
|
|
xsize IdxOfIC(const XString &S, xsize pos = 0) const { return IdxOfIC(S.c_str(), S.length(), pos); }
|
|
bool ExistInIC(const char* s, xsize s_len, xsize pos = 0) const { return IdxOfIC(s, s_len, pos) != MAX_XSIZE; }
|
|
bool ExistInIC(const char* s, xsize pos = 0) const { return IdxOfIC(s, pos) != MAX_XSIZE; }
|
|
bool ExistInIC(const XString &S, xsize pos = 0) const { return IdxOfIC(S, pos) != MAX_XSIZE; }
|
|
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
bool ExistInIAC(const XString &S) const { return IdxOfIC(S) != MAX_XSIZE; }
|
|
#endif
|
|
|
|
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
xsize IdxOfIAC(const XString &S, xsize Pos = 0) const;
|
|
#endif
|
|
|
|
|
|
xsize RIdxOf(const char* s, xsize s_len, xsize pos) const;
|
|
xsize RIdxOf(const char* s, xsize pos = MAX_XSIZE) const { return IdxOf(s, strlen(s), pos); }
|
|
xsize RIdxOf(const XString &S, xsize pos = MAX_XSIZE) const { return IdxOf(S.c_str(), S.length(), pos); }
|
|
|
|
void ToLower(bool FirstCharIsCap = false);
|
|
bool IsLetters() const;
|
|
bool IsLettersNoAccent() const;
|
|
bool IsDigits() const;
|
|
bool IsDigits(xsize pos, xsize count) const;
|
|
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
bool DeleteIC(const XString &S);
|
|
#endif
|
|
void Replace(char c1, char c2);
|
|
XString SubStringReplace(char c1, char c2);
|
|
|
|
int Compare(const char* S) const { return strcmp(data(), (S ? S : "")); }// AsciiStrCmp return 0 or !0, not usual strcmp
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
//IC
|
|
int CompareIC(const char* S) const { return StringCompareIC(data(), (S ? S : "")); }
|
|
// IA
|
|
int CompareIA(const char* S) const { return StringCompareIA(data(), (S ? S : "")); }
|
|
// IAC
|
|
int CompareIAC(const char* S) const { return StringCompareIAC(data(), (S ? S : "")); }
|
|
/*
|
|
int CompareIACSubString(const char* S, size_t LenS) const { return SubStringCompareIAC(data(), length(), S, LenS); } //SubStringCompareIC renvoi 0 (ÈgalitÈ) si Len1 ou Len2 == 0
|
|
int CompareIACSubString(xsize Pos, const char* S, size_t LenS) const { return SubStringCompareIAC(data(Pos), length()-Pos, S, LenS); } //SubStringCompareIC renvoi 0 (ÈgalitÈ) si Len1 ou Len2 == 0
|
|
int CompareIACSubString(xsize Pos, xsize Len, const char* S, size_t LenS) const { return SubStringCompareIAC(data(Pos), Len, S, LenS); }
|
|
*/
|
|
#endif
|
|
|
|
// bool Equal(const char* S) const { return strcmp(data(), (S ? S : "")) == 0; };
|
|
bool Equal(const XString& S) const { return strcmp(c_str(), S.c_str()) == 0; };
|
|
// bool BeginEqual(const char* S) const { return StringBeginEqual(data(), S); }
|
|
// bool SubStringEqual(xsize Pos, const char* S) const { return StringBeginEqual(data(Pos), S); }
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
// IC
|
|
bool EqualIC(const char* S) const { return StringEqualIC(data(), S); }
|
|
bool BeginEqualIC(const char* S) const { return StringBeginEqualIC(data(), S); }
|
|
bool SubStringEqualIC(xsize Pos, const char* S) const { return StringBeginEqualIC(data(Pos), S); }
|
|
bool EqualSubStringIC(const char* S) const { return StringBeginEqualIC(S, data()); }
|
|
// IA
|
|
bool EqualIA(const char* S) const { return CompareIA(S) == 0; };
|
|
// IAC
|
|
bool EqualIAC(const char* S) const { return CompareIAC(S) == 0; };
|
|
bool BeginEqualIAC(const char* S) const { return StringBeginEqualIAC(data(), S); }
|
|
bool SubStringEqualIAC(xsize Pos, const char* S) const { return StringBeginEqualIAC(data(Pos), S); }
|
|
bool EqualSubStringIAC(const char* S) const { return StringBeginEqualIAC(S, data()); }
|
|
|
|
|
|
/* bool EqualIACSubString(const char* S, size_t LenS) const { return CompareIACSubString(S, LenS) == 0; }
|
|
bool EqualIACSubString(xsize Pos, const char* S, size_t LenS) const { return CompareIACSubString(Pos, S, LenS) == 0; }
|
|
bool EqualIACSubString(xsize Pos, xsize Len, const char* S, size_t LenS) const { return CompareIACSubString(Pos, Len, S, LenS) == 0; }
|
|
*/
|
|
#endif
|
|
|
|
XString basename() const;
|
|
XString dirname() const;
|
|
|
|
// size_t Sizeof() const { return size_t(sizeof(xsize)+length()); } // overflow ? underflow ?
|
|
// bool ReadFromBuf(const char *buf, size_t *idx, size_t count);
|
|
// bool WriteToBuf(char *buf, size_t *idx, size_t count) const;
|
|
// bool ReadFromFILE(FILE *fp);
|
|
// bool WriteToFILE(FILE *fp) const;
|
|
// //
|
|
// bool ReadFromXBuffer(XRBuffer &unXBuffer); // Impossible de mettre le XBuffer en const car il y a une variable d'instance de XBuffer incrÈmentÈe par ReadFromXBuffer
|
|
// void CatToXBuffer(XBuffer *unXBuffer) const;
|
|
//// void WriteToXBuffer(XBuffer *unXBuffer, xsize *idx) const;
|
|
|
|
public:
|
|
// OpÈrateur +
|
|
// Chaines
|
|
friend XString operator + (const XString& p1, const XString& p2) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XString& p1, const char *p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// XString operator + (const char *p2 ) { XString s(*this); s+=p2; return s; }
|
|
|
|
friend XString operator + (const char *p1, const XString& p2) { XString s; s.takeValueFrom(p1); s+=p2; return s; }
|
|
// friend XString operator + (const XConstString& p1, const XString& p2) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XString& p1, const XConstString& p2) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XConstString& p1, const XConstString& p2) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XConstString &p1, const char *p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const char *p1, const XConstString &p2) { XString s; s=p1; s+=p2; return s; }
|
|
|
|
// deactivate during refactoring
|
|
// // Char
|
|
// friend XString operator + (const XString& p1, char p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (char p1, const XString& p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// // NumÈrique
|
|
// friend XString operator + (const XString& p1, int p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (int p1, const XString& p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XString& p1, unsigned int p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (unsigned int p1, const XString& p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XString& p1, long p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (long p1, const XString& p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (const XString& p1, unsigned long long p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
// friend XString operator + (unsigned long long p1, const XString& p2 ) { XString s; s=p1; s+=p2; return s; }
|
|
|
|
// OpÈrateur ==
|
|
// Chaines
|
|
friend bool operator == (const XString& s1, const XString& s2) { return s1.Equal(s2); }
|
|
// friend bool operator == (const XString& s1, const char* s2 ) { return s1.Equal(s2); } // during refactor
|
|
// friend bool operator == (const char* s1, const XString& s2) { return s2.Equal(s1); } // during refactor
|
|
// friend bool operator == (const XConstString &s1, const XString& s2) { return s1.Compare(s2) == 0; }
|
|
// friend bool operator == (const XString &s1, const XConstString& s2) { return s1.Compare(s2) == 0; }
|
|
// friend bool operator == (const XConstString &s1, const XConstString& s2) { return s1.Compare(s2) == 0; }
|
|
|
|
friend bool operator != (const XString& s1, const XString& s2) { return !s1.Equal(s2); }
|
|
// friend bool operator != (const XString& s1, const char* s2 ) { return !s1.Equal(s2); } // during refactor
|
|
// friend bool operator != (const char* s1, const XString& s2) { return !s2.Equal(s1); } // during refactor
|
|
// friend bool operator != (const XConstString &s1, const XString& s2) { return s1.Compare(s2) != 0; }
|
|
// friend bool operator != (const XString &s1, const XConstString& s2) { return s1.Compare(s2) != 0; }
|
|
// friend bool operator != (const XConstString &s1, const XConstString& s2) { return s1.Compare(s2) != 0; }
|
|
|
|
// friend bool operator < (const XString& s1, const XString& s2) { return s1.Compare(s2) < 0; }
|
|
// friend bool operator < (const XString& s1, const char* s2 ) { return s1.Compare(s2) < 0; }
|
|
// friend bool operator < (const char* s1, const XString& s2) { return s2.Compare(s1) > 0; }
|
|
//
|
|
// friend bool operator > (const XString& s1, const XString& s2) { return s1.Compare(s2) > 0; }
|
|
// friend bool operator > (const XString& s1, const char* s2 ) { return s1.Compare(s2) > 0; }
|
|
// friend bool operator > (const char* s1, const XString& s2) { return s2.Compare(s1) < 0; }
|
|
//
|
|
// friend bool operator <= (const XString& s1, const XString& s2) { return s1.Compare(s2) <= 0; }
|
|
// friend bool operator <= (const XString& s1, const char* s2 ) { return s1.Compare(s2) <= 0; }
|
|
// friend bool operator <= (const char* s1, const XString& s2) { return s2.Compare(s1) >= 0; }
|
|
//
|
|
// friend bool operator >= (const XString& s1, const XString& s2) { return s1.Compare(s2) >= 0; }
|
|
// friend bool operator >= (const XString& s1, const char* s2 ) { return s1.Compare(s2) >= 0; }
|
|
// friend bool operator >= (const char* s1, const XString& s2) { return s2.Compare(s1) <= 0; }
|
|
|
|
static char to_lower(char ch) { return (((ch >= L'A') && (ch <= L'Z')) ? ((ch - L'A') + L'a') : ch); }
|
|
};
|
|
|
|
extern const XString NullXString;
|
|
|
|
XString operator"" _XS ( const char* s, size_t len);
|
|
|
|
XString SPrintf(const char *format, ...) __attribute__((format(printf, 1, 2)));
|
|
XString SubString(const char *s, xsize s_len, xsize pos, xsize count);
|
|
inline XString SubString(const char *s, xsize pos, xsize count) { return SubString(s, strlen(s), pos, count); }
|
|
inline XString SubString(const XString& S, xsize pos, xsize count) { return SubString(S.c_str(), S.length(), pos, count); }
|
|
|
|
|
|
#ifdef TODO_skqdjfhksqjhfksjqdf
|
|
XString ToAlpha(const char *S);
|
|
XString ToAlpha(const XString &S);
|
|
XString ToLower(const char *S, bool FirstCharIsCap = false);
|
|
XString ToUpper(const char *S);
|
|
#endif
|
|
// Deactivate assignment during refactoring to avoid confusion
|
|
//XString CleanCtrl(const XString &S);
|
|
|
|
#endif
|