mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-17 09:41:21 +00:00
c8cdb52863
actually work. - Turned the list of TabCommands into a TArray because I saw lots of console commands in the memory leak report at exit. Then I realized those were actually key bindings, so I changed the Bindings and DoubleBindings arrays into FString arrays. - Fixed: FStringCVar was missing a destructor. - Added TArray::Insert(). - Fixed: TArray::Delete() used memmove(). - Renamed Malloc(), Realloc(), and Calloc() to M_Malloc(), M_Realloc(), and M_Calloc() so that the debug versions can be defined as macros. - Enabled the CRT's memory leak detection in WinMain(). - Moved contents of PO_DeInit() into P_FreeLevelData(). - Removed "PolyBlockMap = NULL;" from P_SetupLevel(), because the P_FreeLevelData() call it makes next does the exact same thing, but also freeing it if needed. - Fixed: Unneeded memcpy in UnpackUserCmd() when ucmd and basis are the same SVN r75 (trunk)
235 lines
7.1 KiB
C++
235 lines
7.1 KiB
C++
#ifndef ZSTRING_H
|
|
#define ZSTRING_H
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include "tarray.h"
|
|
|
|
//#define NOPOOLS
|
|
class FString
|
|
{
|
|
public:
|
|
FString () : Chars(NULL) {}
|
|
|
|
// Copy constructors
|
|
FString (const FString &other) { Chars = NULL; *this = other; }
|
|
FString (const char *copyStr);
|
|
FString (const char *copyStr, size_t copyLen);
|
|
FString (char oneChar);
|
|
|
|
// Concatenation constructors
|
|
FString (const FString &head, const FString &tail);
|
|
FString (const FString &head, const char *tail);
|
|
FString (const FString &head, char tail);
|
|
FString (const char *head, const FString &tail);
|
|
FString (const char *head, const char *tail);
|
|
FString (char head, const FString &tail);
|
|
|
|
~FString ();
|
|
|
|
operator char *() { return Chars; }
|
|
operator const char *() const { return Chars; }
|
|
|
|
char *GetChars() const { return Chars; }
|
|
char &operator[] (int index) { return Chars[index]; }
|
|
char &operator[] (size_t index) { return Chars[index]; }
|
|
|
|
FString &operator = (const FString &other);
|
|
FString &operator = (const char *copyStr);
|
|
|
|
FString operator + (const FString &tail) const;
|
|
FString operator + (const char *tail) const;
|
|
FString operator + (char tail) const;
|
|
friend FString operator + (const char *head, const FString &tail);
|
|
friend FString operator + (char head, const FString &tail);
|
|
|
|
FString &operator += (const FString &tail);
|
|
FString &operator += (const char *tail);
|
|
FString &operator += (char tail);
|
|
|
|
FString Left (size_t numChars) const;
|
|
FString Right (size_t numChars) const;
|
|
FString Mid (size_t pos, size_t numChars) const;
|
|
|
|
long IndexOf (const FString &substr, long startIndex=0) const;
|
|
long IndexOf (const char *substr, long startIndex=0) const;
|
|
long IndexOf (char subchar, long startIndex=0) const;
|
|
|
|
long IndexOfAny (const FString &charset, long startIndex=0) const;
|
|
long IndexOfAny (const char *charset, long startIndex=0) const;
|
|
|
|
long LastIndexOf (const FString &substr) const;
|
|
long LastIndexOf (const char *substr) const;
|
|
long LastIndexOf (char subchar) const;
|
|
long LastIndexOf (const FString &substr, long endIndex) const;
|
|
long LastIndexOf (const char *substr, long endIndex) const;
|
|
long LastIndexOf (char subchar, long endIndex) const;
|
|
long LastIndexOf (const char *substr, long endIndex, size_t substrlen) const;
|
|
|
|
long LastIndexOfAny (const FString &charset) const;
|
|
long LastIndexOfAny (const char *charset) const;
|
|
long LastIndexOfAny (const FString &charset, long endIndex) const;
|
|
long LastIndexOfAny (const char *charset, long endIndex) const;
|
|
|
|
void ToUpper ();
|
|
void ToLower ();
|
|
void SwapCase ();
|
|
|
|
void StripLeft ();
|
|
void StripLeft (const FString &charset);
|
|
void StripLeft (const char *charset);
|
|
|
|
void StripRight ();
|
|
void StripRight (const FString &charset);
|
|
void StripRight (const char *charset);
|
|
|
|
void StripLeftRight ();
|
|
void StripLeftRight (const FString &charset);
|
|
void StripLeftRight (const char *charset);
|
|
|
|
void Insert (size_t index, const FString &instr);
|
|
void Insert (size_t index, const char *instr);
|
|
void Insert (size_t index, const char *instr, size_t instrlen);
|
|
|
|
void ReplaceChars (char oldchar, char newchar);
|
|
void ReplaceChars (const char *oldcharset, char newchar);
|
|
|
|
void StripChars (char killchar);
|
|
void StripChars (const char *killchars);
|
|
|
|
void MergeChars (char merger);
|
|
void MergeChars (char merger, char newchar);
|
|
void MergeChars (const char *charset, char newchar);
|
|
|
|
void Substitute (const FString &oldstr, const FString &newstr);
|
|
void Substitute (const char *oldstr, const FString &newstr);
|
|
void Substitute (const FString &oldstr, const char *newstr);
|
|
void Substitute (const char *oldstr, const char *newstr);
|
|
void Substitute (const char *oldstr, const char *newstr, size_t oldstrlen, size_t newstrlen);
|
|
|
|
void Format (const char *fmt, ...);
|
|
void VFormat (const char *fmt, va_list arglist);
|
|
|
|
bool IsInt () const;
|
|
bool IsFloat () const;
|
|
long ToLong (int base=0) const;
|
|
unsigned long ToULong (int base=0) const;
|
|
double ToDouble () const;
|
|
|
|
size_t Len() const { return Chars == NULL ? 0 : ((StringHeader *)(Chars - sizeof(StringHeader)))->Len; }
|
|
bool IsEmpty() const { return Len() == 0; }
|
|
|
|
void Resize (long newlen);
|
|
|
|
int Compare (const FString &other) const { return strcmp (Chars, other.Chars); }
|
|
int Compare (const char *other) const { return strcmp (Chars, other); }
|
|
|
|
int CompareNoCase (const FString &other) const { return stricmp (Chars, other.Chars); }
|
|
int CompareNoCase (const char *other) const { return stricmp (Chars, other); }
|
|
|
|
protected:
|
|
struct StringHeader
|
|
{
|
|
#ifndef NOPOOLS
|
|
FString *Owner; // FString this char array belongs to
|
|
#endif
|
|
size_t Len; // Length of FString, excluding terminating null
|
|
};
|
|
struct Pool;
|
|
struct PoolGroup
|
|
{
|
|
#ifndef NOPOOLS
|
|
~PoolGroup ();
|
|
Pool *Pools;
|
|
Pool *FindPool (char *chars) const;
|
|
static StringHeader *GetHeader (char *chars);
|
|
#endif
|
|
char *Alloc (FString *owner, size_t len);
|
|
char *Realloc (FString *owner, char *chars, size_t newlen);
|
|
void Free (char *chars);
|
|
};
|
|
|
|
FString (size_t len);
|
|
StringHeader *GetHeader () const;
|
|
|
|
static int FormatHelper (void *data, const char *str, int len);
|
|
static void StrCopy (char *to, const char *from, size_t len);
|
|
static void StrCopy (char *to, const FString &from);
|
|
static PoolGroup Pond;
|
|
|
|
char *Chars;
|
|
|
|
#ifndef __GNUC__
|
|
template<> friend void CopyForTArray<FString> (FString &dst, FString &src)
|
|
{
|
|
// When a TArray is resized, we just need to update the Owner, because
|
|
// the old copy is going to go away very soon. No need to call the
|
|
// destructor, either, because full ownership is transferred to the
|
|
// new FString.
|
|
char *chars = src.Chars;
|
|
dst.Chars = chars;
|
|
if (chars != NULL)
|
|
{
|
|
((FString::StringHeader *)(chars - sizeof(FString::StringHeader)))->Owner = &dst;
|
|
}
|
|
}
|
|
#else
|
|
template<class FString> friend inline void CopyForTArray (FString &dst, FString &src);
|
|
#endif
|
|
|
|
private:
|
|
void *operator new (size_t size, FString *addr)
|
|
{
|
|
return addr;
|
|
}
|
|
void operator delete (void *, FString *)
|
|
{
|
|
}
|
|
};
|
|
|
|
#ifdef __GNUC__
|
|
template<> inline void CopyForTArray<FString> (FString &dst, FString &src)
|
|
{
|
|
// When a TArray is resized, we just need to update the Owner, because
|
|
// the old copy is going to go away very soon. No need to call the
|
|
// destructor, either, because full ownership is transferred to the
|
|
// new FString.
|
|
char *chars = src.Chars;
|
|
dst.Chars = chars;
|
|
if (chars != NULL)
|
|
{
|
|
((FString::StringHeader *)(chars - sizeof(FString::StringHeader)))->Owner = &dst;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
namespace StringFormat
|
|
{
|
|
enum
|
|
{
|
|
// Format specification flags
|
|
F_MINUS = 1,
|
|
F_PLUS = 2,
|
|
F_ZERO = 4,
|
|
F_BLANK = 8,
|
|
F_HASH = 16,
|
|
|
|
F_SIGNED = 32,
|
|
F_NEGATIVE = 64,
|
|
F_ZEROVALUE = 128,
|
|
|
|
// Format specification size prefixes
|
|
F_HALFHALF = 0x1000, // hh
|
|
F_HALF = 0x2000, // h
|
|
F_LONG = 0x3000, // l
|
|
F_LONGLONG = 0x4000, // ll or I64
|
|
F_BIGI = 0x5000 // I
|
|
};
|
|
typedef int (*OutputFunc)(void *data, const char *str, int len);
|
|
|
|
int VWorker (OutputFunc output, void *outputData, const char *fmt, va_list arglist);
|
|
int Worker (OutputFunc output, void *outputData, const char *fmt, ...);
|
|
};
|
|
|
|
#endif
|