Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

indent

Browse source
This commit is contained in:
L 2023-02-04 19:56:06 +01:00
parent 2763cfbd46
commit 294ca5ffd2
10 changed files with 1776 additions and 1840 deletions
Download patch file Download diff file Expand all files Collapse all files

352
code/qcommon/class.h
View file

@ -25,9 +25,9 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef __CLASS_H__
#define __CLASS_H__
#include "q_shared.h"
#include "container.h"
#include "con_set.h"
#include "container.h"
#include "q_shared.h"
#include "str.h"
#include "const_str.h"
@ -35,208 +35,206 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
class Class;
class Event;
#define isSubclassOf( classname )inheritsFrom( &classname::ClassInfo )
#define isSuperclassOf( classname )isInheritedBy( &classname::ClassInfo )
#define isSubclassOf(classname) inheritsFrom(&classname::ClassInfo)
#define isSuperclassOf(classname) isInheritedBy(&classname::ClassInfo)
#ifndef NO_SCRIPTENGINE
#define CLASS_DECLARATION( parentclass, classname, classid ) \
ClassDef classname::ClassInfo \
( \
#classname, classid, #parentclass, \
(ResponseDef<Class> *)classname::Responses, \
classname::_newInstance, sizeof( classname ) \
); \
void *classname::_newInstance( void ) \
{ \
return new classname; \
} \
ClassDef *classname::classinfo( void ) const \
{ \
return &(classname::ClassInfo); \
} \
ClassDef *classname::classinfostatic( void ) \
{ \
return &(classname::ClassInfo); \
} \
void classname::AddWaitTill( str s ) \
{ \
classname::ClassInfo.AddWaitTill( s ); \
} \
void classname::AddWaitTill( const_str s ) \
{ \
classname::ClassInfo.AddWaitTill( s ); \
} \
void classname::RemoveWaitTill( str s ) \
{ \
classname::ClassInfo.RemoveWaitTill( s ); \
} \
void classname::RemoveWaitTill( const_str s ) \
{ \
classname::ClassInfo.RemoveWaitTill( s ); \
} \
bool classname::WaitTillDefined( str s ) \
{ \
return classname::ClassInfo.WaitTillDefined( s ); \
} \
bool classname::WaitTillDefined( const_str s ) \
{ \
return classname::ClassInfo.WaitTillDefined( s ); \
} \
ResponseDef<classname> classname::Responses[] =
#define CLASS_DECLARATION(parentclass, classname, classid) \
ClassDef classname::ClassInfo(#classname, classid, #parentclass, \
(ResponseDef<Class>*)classname::Responses, \
classname::_newInstance, sizeof(classname)); \
void* classname::_newInstance(void) \
{ \
return new classname; \
} \
ClassDef* classname::classinfo(void) const \
{ \
return &(classname::ClassInfo); \
} \
ClassDef* classname::classinfostatic(void) \
{ \
return &(classname::ClassInfo); \
} \
void classname::AddWaitTill(str s) \
{ \
classname::ClassInfo.AddWaitTill(s); \
} \
void classname::AddWaitTill(const_str s) \
{ \
classname::ClassInfo.AddWaitTill(s); \
} \
void classname::RemoveWaitTill(str s) \
{ \
classname::ClassInfo.RemoveWaitTill(s); \
} \
void classname::RemoveWaitTill(const_str s) \
{ \
classname::ClassInfo.RemoveWaitTill(s); \
} \
bool classname::WaitTillDefined(str s) \
{ \
return classname::ClassInfo.WaitTillDefined(s); \
} \
bool classname::WaitTillDefined(const_str s) \
{ \
return classname::ClassInfo.WaitTillDefined(s); \
} \
ResponseDef<classname> classname::Responses[] =
#define CLASS_PROTOTYPE( classname ) \
public: \
static ClassDef ClassInfo; \
static ClassDefHook _ClassInfo_; \
static void *_newInstance( void ); \
static ClassDef *classinfostatic(void); \
ClassDef *classinfo(void) const override; \
static void AddWaitTill( str s ); \
static void AddWaitTill( const_str s ); \
static void RemoveWaitTill( str s ); \
static void RemoveWaitTill( const_str s ); \
static bool WaitTillDefined( str s ); \
static bool WaitTillDefined( const_str s ); \
static ResponseDef<classname> Responses[]
#define CLASS_PROTOTYPE(classname) \
public: \
static ClassDef ClassInfo; \
static ClassDefHook _ClassInfo_; \
static void* _newInstance(void); \
static ClassDef* classinfostatic(void); \
ClassDef* classinfo(void) const override; \
static void AddWaitTill(str s); \
static void AddWaitTill(const_str s); \
static void RemoveWaitTill(str s); \
static void RemoveWaitTill(const_str s); \
static bool WaitTillDefined(str s); \
static bool WaitTillDefined(const_str s); \
static ResponseDef<classname> Responses[]
#else
#define CLASS_DECLARATION( parentclass, classname, classid ) \
ClassDef classname::ClassInfo \
( \
#classname, classid, #parentclass, \
(ResponseDef<Class> *)classname::Responses, \
classname::_newInstance, sizeof( classname ) \
); \
void *classname::_newInstance( void ) \
{ \
return new classname; \
} \
ClassDef *classname::classinfo( void ) const \
{ \
return &(classname::ClassInfo); \
} \
ClassDef *classname::classinfostatic( void ) \
{ \
return &(classname::ClassInfo); \
} \
ResponseDef<classname> classname::Responses[] =
#define CLASS_DECLARATION(parentclass, classname, classid) \
ClassDef classname::ClassInfo(#classname, classid, #parentclass, \
(ResponseDef<Class>*)classname::Responses, \
classname::_newInstance, sizeof(classname)); \
void* classname::_newInstance(void) \
{ \
return new classname; \
} \
ClassDef* classname::classinfo(void) const \
{ \
return &(classname::ClassInfo); \
} \
ClassDef* classname::classinfostatic(void) \
{ \
return &(classname::ClassInfo); \
} \
ResponseDef<classname> classname::Responses[] =
#define CLASS_PROTOTYPE( classname ) \
public: \
static ClassDef ClassInfo; \
static ClassDefHook _ClassInfo_; \
static void *_newInstance( void ); \
static ClassDef *classinfostatic(void); \
ClassDef *classinfo(void) const override; \
static ResponseDef<classname> Responses[]
#define CLASS_PROTOTYPE(classname) \
public: \
static ClassDef ClassInfo; \
static ClassDefHook _ClassInfo_; \
static void* _newInstance(void); \
static ClassDef* classinfostatic(void); \
ClassDef* classinfo(void) const override; \
static ResponseDef<classname> Responses[]
#endif
typedef void ( Class::*Response )( Event *ev );
typedef void (Class::*Response)(Event* ev);
class EventDef;
template< class Type >
template<class Type>
struct ResponseDef
{
Event *event;
void ( Type::*response )( Event *ev );
EventDef *def;
Event* event;
void (Type::*response)(Event* ev);
EventDef* def;
};
class ClassDef
{
public:
const char *classname;
const char *classID;
const char *superclass;
void *(*newInstance)(void);
int classSize;
ResponseDef<Class> *responses;
ResponseDef<Class> **responseLookup;
ClassDef *super;
ClassDef *next;
ClassDef *prev;
const char* classname;
const char* classID;
const char* superclass;
void* (*newInstance)(void);
int classSize;
ResponseDef<Class>* responses;
ResponseDef<Class>** responseLookup;
ClassDef* super;
ClassDef* next;
ClassDef* prev;
#ifndef NO_SCRIPTENGINE
con_set<const_str, const_str> *waitTillSet;
con_set<const_str, const_str>* waitTillSet;
#endif
int numEvents;
int numEvents;
static ClassDef *classlist;
static int numclasses;
static ClassDef* classlist;
static int numclasses;
static void BuildEventResponses();
static void BuildEventResponses();
void BuildResponseList();
void BuildResponseList();
static int dump_numclasses;
static int dump_numevents;
static Container< int > sortedList;
static Container< ClassDef * > sortedClassList;
static int dump_numclasses;
static int dump_numevents;
static Container<int> sortedList;
static Container<ClassDef*> sortedClassList;
ClassDef();
~ClassDef();
ClassDef();
~ClassDef();
static int compareClasses( const void *arg1, const void *arg2 );
static void SortClassList( Container< ClassDef * > *sortedList );
static int compareClasses(const void* arg1, const void* arg2);
static void SortClassList(Container<ClassDef*>* sortedList);
#ifndef NO_SCRIPTENGINE
void AddWaitTill( str s );
void AddWaitTill( const_str s );
void RemoveWaitTill( str s );
void RemoveWaitTill( const_str s );
bool WaitTillDefined( str s );
bool WaitTillDefined( const_str s );
void AddWaitTill(str s);
void AddWaitTill(const_str s);
void RemoveWaitTill(str s);
void RemoveWaitTill(const_str s);
bool WaitTillDefined(str s);
bool WaitTillDefined(const_str s);
#endif
/* Create-a-class function */
ClassDef( const char *classname, const char *classID, const char *superclass, ResponseDef<Class> *responses,
void *( *newInstance )( void ), int classSize );
void CreateInternal( const char *classname, const char *classID, const char *superclass, ResponseDef<Class> *responses,
void *( *newInstance )( void ), int classSize );
void CreateInternalWin( const char *classname, const char *classID, const char *superclass, ResponseDef<Class> *responses,
void *( *newInstance )( void ), int classSize );
/* Create-a-class function */
ClassDef(const char* classname, const char* classID, const char* superclass,
ResponseDef<Class>* responses, void* (*newInstance)(void),
int classSize);
void CreateInternal(const char* classname, const char* classID,
const char* superclass, ResponseDef<Class>* responses,
void* (*newInstance)(void), int classSize);
void CreateInternalWin(const char* classname, const char* classID,
const char* superclass,
ResponseDef<Class>* responses,
void* (*newInstance)(void), int classSize);
EventDef *GetDef( int eventnum );
int GetFlags( Event *event );
EventDef* GetDef(int eventnum);
int GetFlags(Event* event);
void Destroy();
void Destroy();
};
ClassDef *getClassList( void );
qboolean checkInheritance( const ClassDef *superclass, const ClassDef *subclass );
qboolean checkInheritance( ClassDef *superclass, const char *subclass );
qboolean checkInheritance( const char *superclass, const char *subclass );
void CLASS_Print( FILE *class_file, const char *fmt, ... );
void ClassEvents( const char *classname, qboolean print_to_disk );
void DumpClass( FILE * class_file, const char * className );
void DumpAllClasses( void );
ClassDef* getClassList(void);
qboolean checkInheritance(const ClassDef* superclass, const ClassDef* subclass);
qboolean checkInheritance(ClassDef* superclass, const char* subclass);
qboolean checkInheritance(const char* superclass, const char* subclass);
void CLASS_Print(FILE* class_file, const char* fmt, ...);
void ClassEvents(const char* classname, qboolean print_to_disk);
void DumpClass(FILE* class_file, const char* className);
void DumpAllClasses(void);
class ClassDefHook
{
private:
ClassDef *classdef;
ClassDef* classdef;
public:
//void * operator new( size_t );
//void operator delete( void * );
// void * operator new( size_t );
// void operator delete( void * );
ClassDefHook();
~ClassDefHook();
ClassDefHook();
~ClassDefHook();
/* Hook-a-class function */
ClassDefHook( ClassDef * classdef, ResponseDef<Class> *responses );
/* Hook-a-class function */
ClassDefHook(ClassDef* classdef, ResponseDef<Class>* responses);
};
ClassDef *getClassForID( const char *name );
ClassDef *getClass( const char * name );
ClassDef *getClassList( void );
void listAllClasses( void );
void listInheritanceOrder( const char *classname );
ClassDef* getClassForID(const char* name);
ClassDef* getClass(const char* name);
ClassDef* getClassList(void);
void listAllClasses(void);
void listInheritanceOrder(const char* classname);
class SafePtrBase;
class Archiver;
@ -244,40 +242,40 @@ class Archiver;
class Class
{
public:
SafePtrBase *SafePtrList;
SafePtrBase* SafePtrList;
private:
void ClearSafePointers();
void ClearSafePointers();
public:
#ifndef _DEBUG_MEM
void * operator new( size_t );
void operator delete( void * );
void* operator new(size_t);
void operator delete(void*);
#endif
Class();
virtual ~Class();
Class();
virtual ~Class();
virtual void Archive( Archiver& arc );
virtual void Archive(Archiver& arc);
static ClassDef ClassInfo;
static ClassDefHook _ClassInfo_;
static void *_newInstance( void );
static ClassDef *classinfostatic(void);
virtual ClassDef *classinfo(void) const;
static ResponseDef<Class> Responses[];
static ClassDef ClassInfo;
static ClassDefHook _ClassInfo_;
static void* _newInstance(void);
static ClassDef* classinfostatic(void);
virtual ClassDef* classinfo(void) const;
static ResponseDef<Class> Responses[];
const char *getClassID( void ) const;
const char *getClassname( void ) const;
const char *getSuperclass( void ) const;
const char* getClassID(void) const;
const char* getClassname(void) const;
const char* getSuperclass(void) const;
qboolean inheritsFrom( ClassDef *c ) const;
qboolean inheritsFrom( const char * name ) const;
qboolean isInheritedBy( const char * name ) const;
qboolean isInheritedBy( ClassDef *c ) const;
qboolean inheritsFrom(ClassDef* c) const;
qboolean inheritsFrom(const char* name) const;
qboolean isInheritedBy(const char* name) const;
qboolean isInheritedBy(ClassDef* c) const;
void warning( const char *function, const char *format, ... );
void error( const char *function, const char *format, ... );
void warning(const char* function, const char* format, ...);
void error(const char* function, const char* format, ...);
};
#include "safeptr.h"

114
code/qcommon/configurator.h
View file

@ -27,84 +27,88 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include <listener.h>
#define MAX_CONFIGURATOR_ARRAY_SIZE 2048
#define MAX_CONFIGURATOR_ARRAY_SIZE 2048
typedef struct configValue_s {
bool m_bNeedWrite;
str value;
bool m_bNeedWrite;
str value;
} configValue_t;
typedef struct configKey_s {
bool m_bNeedWrite;
str name;
Container< configValue_t > value;
bool m_bArray;
bool m_bNeedWrite;
str name;
Container<configValue_t> value;
bool m_bArray;
} configKey_t;
typedef struct configSection_s {
bool m_bNeedWrite;
str name;
Container< configKey_t * > key;
bool m_bNeedWrite;
str name;
Container<configKey_t*> key;
} configSection_t;
enum {
LINE_EMPTY,
LINE_COMMENT,
LINE_SECTION,
LINE_VALUE,
LINE_ERROR
};
enum { LINE_EMPTY, LINE_COMMENT, LINE_SECTION, LINE_VALUE, LINE_ERROR };
class Configurator : public Class {
class Configurator : public Class
{
private:
str m_filename;
bool m_bNoWrite;
bool m_bNeedWrite;
str m_filename;
bool m_bNoWrite;
bool m_bNeedWrite;
con_set< str, configSection_t > m_sections;
Container< configSection_t * > m_reverseSections;
con_set<str, configSection_t> m_sections;
Container<configSection_t*> m_reverseSections;
private:
size_t GetLine( char *dest, const char *data, size_t size );
str GetValue( const char *section, const char *key, str defaultValue, int index = -1 );
configKey_t *GetKey( const char *section, const char *key, int index = -1 );
size_t GetLine(char* dest, const char* data, size_t size);
str GetValue(const char* section, const char* key, str defaultValue,
int index = -1);
configKey_t* GetKey(const char* section, const char* key, int index = -1);
int CutLine( char *data );
bool SetupLine( char *line, int& lineno, size_t& len, size_t& last );
bool FindData( int type, const char *section, const char *key, size_t *offset, const char *data, size_t size );
void ParseData( const char *data, size_t size );
void WriteData( char **data, size_t *size );
void WriteData2( char **data, size_t *size );
int ParseLine( char *line, char *section, char *key, char *value );
int CutLine(char* data);
bool SetupLine(char* line, int& lineno, size_t& len, size_t& last);
bool FindData(int type, const char* section, const char* key,
size_t* offset, const char* data, size_t size);
void ParseData(const char* data, size_t size);
void WriteData(char** data, size_t* size);
void WriteData2(char** data, size_t* size);
int ParseLine(char* line, char* section, char* key, char* value);
configSection_t *CreateSection( const char *section );
configSection_t *FindSection( const char *section );
int GetKeyArray( char *key );
int GetKeyArray( str& key );
configKey_t *CreateKey( configSection_t *section, const char *key, unsigned int *index );
configKey_t *FindKey( configSection_t *section, const char *key );
void RemoveSection( configSection_t *section );
void RemoveKey( configSection_t *section, configKey_t *key );
configSection_t* CreateSection(const char* section);
configSection_t* FindSection(const char* section);
int GetKeyArray(char* key);
int GetKeyArray(str& key);
configKey_t* CreateKey(configSection_t* section, const char* key,
unsigned int* index);
configKey_t* FindKey(configSection_t* section, const char* key);
void RemoveSection(configSection_t* section);
void RemoveKey(configSection_t* section, configKey_t* key);
public:
CLASS_PROTOTYPE( Configurator );
CLASS_PROTOTYPE(Configurator);
Configurator( const char *filename );
Configurator();
~Configurator();
Configurator(const char* filename);
Configurator();
~Configurator();
void Parse( const char *filename );
void Close();
void SetWrite( bool bWrite );
void Parse(const char* filename);
void Close();
void SetWrite(bool bWrite);
str GetString( const char *section, const char *key, str defaultValue, int index = -1 );
int GetInteger( const char *section, const char *key, int defaultValue, int index = -1 );
float GetFloat( const char *section, const char *key, float defaultValue, int index = -1 );
void SetString( const char *section, const char *key, str value, int index = -1 );
void SetInteger( const char *section, const char *key, int value, int index = -1 );
void SetFloat( const char *section, const char *key, float value, int index = -1 );
str GetString(const char* section, const char* key, str defaultValue,
int index = -1);
int GetInteger(const char* section, const char* key, int defaultValue,
int index = -1);
float GetFloat(const char* section, const char* key, float defaultValue,
int index = -1);
void SetString(const char* section, const char* key, str value,
int index = -1);
void SetInteger(const char* section, const char* key, int value,
int index = -1);
void SetFloat(const char* section, const char* key, float value,
int index = -1);
};
void test_config( void );
void test_config(void);
#endif /* __CONFIGURATOR_H__ */

588
code/qcommon/container.h
View file

@ -27,145 +27,152 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifdef GAME_DLL
#ifdef WIN32
#define glbprintf( text ) gi.Printf( text )
#define glbprintf(text) gi.Printf(text)
#else
#define glbprintf( text )
#define glbprintf(text)
#endif
#elif defined CGAME_DLL
#define glbprintf( text ) cgi.Printf( text )
#define glbprintf(text) cgi.Printf(text)
#else
#define glbprintf( text ) printf( text )
#define glbprintf(text) printf(text)
#endif
#ifdef _DEBUG
#define CONTAINER_Error( id, text ) glbprintf( text ); assert( 0 );
#define CONTAINER_Error(id, text) \
glbprintf(text); \
assert(0);
#else
#define CONTAINER_Error( id, text ) throw( text ) //gi.Error
#define CONTAINER_Error(id, text) throw(text) // gi.Error
#endif
#define CONTAINER_DPrintf( text ) glbprintf( text )
#define CONTAINER_WDPrintf( text ) glbprintf( text )
#define CONTAINER_DPrintf(text) glbprintf(text)
#define CONTAINER_WDPrintf(text) glbprintf(text)
class Archiver;
template< class Type >
template<class Type>
class Container
{
private:
Type *objlist;
int numobjects;
int maxobjects;
Type* objlist;
int numobjects;
int maxobjects;
private:
void Copy( const Container<Type>& container );
void Copy(const Container<Type>& container);
public:
Container();
Container( const Container<Type>& container );
~Container();
Container();
Container(const Container<Type>& container);
~Container();
void Archive( Archiver& arc );
void Archive( Archiver& arc, void( *ArchiveFunc )( Archiver &arc, Type *obj ) );
void Archive(Archiver& arc);
void Archive(Archiver& arc, void (*ArchiveFunc)(Archiver& arc, Type* obj));
int AddObject( const Type& obj );
int AddUniqueObject( const Type& obj );
void AddObjectAt( int index, const Type& obj );
Type *AddressOfObjectAt( int index );
// void Archive( Archiver &arc );
void ClearObjectList( void );
void Fix( void );
void FreeObjectList( void );
int IndexOfObject( const Type& obj );
void InsertObjectAt( int index, const Type& obj );
int MaxObjects( void ) const;
int NumObjects( void ) const;
Type& ObjectAt( const size_t index ) const;
bool ObjectInList( const Type& obj );
void RemoveObjectAt( int index );
void RemoveObject( const Type& obj );
void Reset( void );
void Resize( int maxelements );
void SetObjectAt( int index, const Type& obj );
void Sort( int( *compare )( const void *elem1, const void *elem2 ) );
Type& operator[]( const int index ) const;
Container<Type>& operator=( const Container<Type>& container );
int AddObject(const Type& obj);
int AddUniqueObject(const Type& obj);
void AddObjectAt(int index, const Type& obj);
Type* AddressOfObjectAt(int index);
// void Archive( Archiver &arc );
void ClearObjectList(void);
void Fix(void);
void FreeObjectList(void);
int IndexOfObject(const Type& obj);
void InsertObjectAt(int index, const Type& obj);
int MaxObjects(void) const;
int NumObjects(void) const;
Type& ObjectAt(const size_t index) const;
bool ObjectInList(const Type& obj);
void RemoveObjectAt(int index);
void RemoveObject(const Type& obj);
void Reset(void);
void Resize(int maxelements);
void SetObjectAt(int index, const Type& obj);
void Sort(int (*compare)(const void* elem1, const void* elem2));
Type& operator[](const int index) const;
Container<Type>& operator=(const Container<Type>& container);
};
template< class Type >
template<class Type>
Container<Type>::Container()
{
objlist = NULL;
numobjects = 0;
maxobjects = 0;
objlist = NULL;
numobjects = 0;
maxobjects = 0;
}
template< class Type >
Container<Type>::Container( const Container<Type>& container )
template<class Type>
Container<Type>::Container(const Container<Type>& container)
{
objlist = NULL;
objlist = NULL;
Copy( container );
Copy(container);
}
template< class Type >
template<class Type>
Container<Type>::~Container()
{
FreeObjectList();
FreeObjectList();
}
template< class Type >
int Container<Type>::AddObject( const Type& obj )
template<class Type>
int Container<Type>::AddObject(const Type& obj)
{
if ( !objlist )
Resize( 10 );
if (!objlist) {
Resize(10);
}
if ( numobjects >= maxobjects ) {
Resize( numobjects * 2 );
}
if (numobjects >= maxobjects) {
Resize(numobjects * 2);
}
objlist[numobjects] = obj;
numobjects++;
objlist[numobjects] = obj;
numobjects++;
return numobjects;
return numobjects;
}
template< class Type >
int Container<Type>::AddUniqueObject( const Type& obj )
template<class Type>
int Container<Type>::AddUniqueObject(const Type& obj)
{
int index;
int index;
index = IndexOfObject( obj );
index = IndexOfObject(obj);
if ( !index ) {
index = AddObject( obj );
}
if (!index) {
index = AddObject(obj);
}
return index;
return index;
}
template< class Type >
void Container<Type>::AddObjectAt( int index, const Type& obj )
template<class Type>
void Container<Type>::AddObjectAt(int index, const Type& obj)
{
if ( index > maxobjects )
Resize( index );
if (index > maxobjects) {
Resize(index);
}
if ( index > numobjects )
numobjects = index;
if (index > numobjects) {
numobjects = index;
}
SetObjectAt( index, obj );
SetObjectAt(index, obj);
}
template< class Type >
Type *Container<Type>::AddressOfObjectAt( int index )
template<class Type>
Type* Container<Type>::AddressOfObjectAt(int index)
{
if ( index > maxobjects ) {
CONTAINER_Error( ERR_DROP, "Container::AddressOfObjectAt : index is greater than maxobjects" );
}
if (index > maxobjects) {
CONTAINER_Error(
ERR_DROP,
"Container::AddressOfObjectAt : index is greater than maxobjects");
}
if ( index > numobjects ) {
numobjects = index;
}
if (index > numobjects) {
numobjects = index;
}
return &objlist[index - 1];
return &objlist[index - 1];
}
/*template< class Type >
@ -174,318 +181,307 @@ void Container<Type>::Archive( Archiver &arc )
}*/
template< class Type >
void Container<Type>::ClearObjectList( void )
template<class Type>
void Container<Type>::ClearObjectList(void)
{
if ( objlist && numobjects )
{
delete[] objlist;
if (objlist && numobjects) {
delete[] objlist;
if ( maxobjects == 0 )
{
objlist = NULL;
return;
}
if (maxobjects == 0) {
objlist = NULL;
return;
}
objlist = new Type[maxobjects];
numobjects = 0;
}
objlist = new Type[maxobjects];
numobjects = 0;
}
}
template< class Type >
void Container<Type>::Fix( void )
template<class Type>
void Container<Type>::Fix(void)
{
if( !objlist || !numobjects ) {
return;
}
if (!objlist || !numobjects) {
return;
}
Type *newlist = new Type[ numobjects ];
int j = 0;
Type* newlist = new Type[numobjects];
int j = 0;
for( int i = 0; i < numobjects; i++ )
{
if( objlist[ i ] == NULL ) {
continue;
}
for (int i = 0; i < numobjects; i++) {
if (objlist[i] == NULL) {
continue;
}
newlist[ j ] = objlist[ i ];
j++;
}
newlist[j] = objlist[i];
j++;
}
numobjects = j;
numobjects = j;
delete[] objlist;
objlist = newlist;
delete[] objlist;
objlist = newlist;
if( !numobjects ) {
ClearObjectList();
}
if (!numobjects) {
ClearObjectList();
}
}
template< class Type >
void Container<Type>::FreeObjectList( void )
template<class Type>
void Container<Type>::FreeObjectList(void)
{
if( objlist ) {
delete[] objlist;
}
if (objlist) {
delete[] objlist;
}
objlist = NULL;
numobjects = 0;
maxobjects = 0;
objlist = NULL;
numobjects = 0;
maxobjects = 0;
}
template< class Type >
int Container<Type>::IndexOfObject( const Type& obj )
template<class Type>
int Container<Type>::IndexOfObject(const Type& obj)
{
int i;
int i;
if ( !objlist ) {
return 0;
}
if (!objlist) {
return 0;
}
for ( i = 0; i < numobjects; i++ )
{
if ( objlist[i] == obj )
{
return i + 1;
}
}
for (i = 0; i < numobjects; i++) {
if (objlist[i] == obj) {
return i + 1;
}
}
return 0;
return 0;
}
template< class Type >
void Container<Type>::InsertObjectAt( int index, const Type& obj )
template<class Type>
void Container<Type>::InsertObjectAt(int index, const Type& obj)
{
if ( ( index <= 0 ) || ( index > numobjects + 1 ) )
{
CONTAINER_Error( ERR_DROP, "Container::InsertObjectAt : index out of range" );
return;
}
if ((index <= 0) || (index > numobjects + 1)) {
CONTAINER_Error(ERR_DROP,
"Container::InsertObjectAt : index out of range");
return;
}
numobjects++;
int arrayIndex = index - 1;
numobjects++;
int arrayIndex = index - 1;
if ( numobjects > maxobjects )
{
maxobjects = numobjects;
if ( !objlist ) {
objlist = new Type[maxobjects];
objlist[arrayIndex] = obj;
return;
}
else
{
Type *temp = objlist;
if ( maxobjects < numobjects )
{
maxobjects = numobjects;
}
if (numobjects > maxobjects) {
maxobjects = numobjects;
if (!objlist) {
objlist = new Type[maxobjects];
objlist[arrayIndex] = obj;
return;
} else {
Type* temp = objlist;
if (maxobjects < numobjects) {
maxobjects = numobjects;
}
objlist = new Type[maxobjects];
objlist = new Type[maxobjects];
int i;
for ( i = arrayIndex - 1; i >= 0; i-- ) {
objlist[i] = temp[i];
}
int i;
for (i = arrayIndex - 1; i >= 0; i--) {
objlist[i] = temp[i];
}
objlist[arrayIndex] = obj;
for ( i = numobjects - 1; i > arrayIndex; i-- ) {
objlist[i] = temp[i - 1];
}
objlist[arrayIndex] = obj;
for (i = numobjects - 1; i > arrayIndex; i--) {
objlist[i] = temp[i - 1];
}
delete[] temp;
}
}
else
{
for ( int i = numobjects - 1; i > arrayIndex; i-- ) {
objlist[i] = objlist[i - 1];
}
objlist[arrayIndex] = obj;
}
delete[] temp;
}
} else {
for (int i = numobjects - 1; i > arrayIndex; i--) {
objlist[i] = objlist[i - 1];
}
objlist[arrayIndex] = obj;
}
}
template< class Type >
int Container<Type>::MaxObjects( void ) const
template<class Type>
int Container<Type>::MaxObjects(void) const
{
return maxobjects;
return maxobjects;
}
template< class Type >
int Container<Type>::NumObjects( void ) const
template<class Type>
int Container<Type>::NumObjects(void) const
{
return numobjects;
return numobjects;
}
template< class Type >
Type& Container<Type>::ObjectAt( const size_t index ) const
template<class Type>
Type& Container<Type>::ObjectAt(const size_t index) const
{
if( ( index <= 0 ) || ( index > numobjects ) ) {
CONTAINER_Error( ERR_DROP, "Container::ObjectAt : index out of range" );
}
if ((index <= 0) || (index > numobjects)) {
CONTAINER_Error(ERR_DROP, "Container::ObjectAt : index out of range");
}
return objlist[index - 1];
return objlist[index - 1];
}
template< class Type >
bool Container<Type>::ObjectInList( const Type& obj )
template<class Type>
bool Container<Type>::ObjectInList(const Type& obj)
{
if ( !IndexOfObject( obj ) ) {
return false;
}
if (!IndexOfObject(obj)) {
return false;
}
return true;
return true;
}
template< class Type >
void Container<Type>::RemoveObjectAt( int index )
template<class Type>
void Container<Type>::RemoveObjectAt(int index)
{
int i;
int i;
if ( !objlist )
return;
if (!objlist) {
return;
}
if ( ( index <= 0 ) || ( index > numobjects ) )
return;
if ((index <= 0) || (index > numobjects)) {
return;
}
i = index - 1;
numobjects--;
i = index - 1;
numobjects--;
for ( i = index - 1; i < numobjects; i++ )
objlist[i] = objlist[i + 1];
for (i = index - 1; i < numobjects; i++) {
objlist[i] = objlist[i + 1];
}
}
template< class Type >
void Container<Type>::RemoveObject( const Type& obj )
template<class Type>
void Container<Type>::RemoveObject(const Type& obj)
{
int index;
int index;
index = IndexOfObject( obj );
index = IndexOfObject(obj);
assert( index );
if ( !index )
{
CONTAINER_WDPrintf( "Container::RemoveObject : Object not in list\n" );
return;
}
assert(index);
if (!index) {
CONTAINER_WDPrintf("Container::RemoveObject : Object not in list\n");
return;
}
RemoveObjectAt( index );
RemoveObjectAt(index);
}
template< class Type >
template<class Type>
void Container<Type>::Reset()
{
objlist = NULL;
numobjects = 0;
maxobjects = 0;
objlist = NULL;
numobjects = 0;
maxobjects = 0;
}
template< class Type >
void Container<Type>::Resize( int maxelements )
template<class Type>
void Container<Type>::Resize(int maxelements)
{
Type* temp;
int i;
Type* temp;
int i;
if ( maxelements <= 0 )
{
FreeObjectList();
return;
}
if (maxelements <= 0) {
FreeObjectList();
return;
}
if ( !objlist )
{
maxobjects = maxelements;
objlist = new Type[maxobjects];
}
else
{
temp = objlist;
if (!objlist) {
maxobjects = maxelements;
objlist = new Type[maxobjects];
} else {
temp = objlist;
maxobjects = maxelements;
maxobjects = maxelements;
if ( maxobjects < numobjects ) {
maxobjects = numobjects;
}
if (maxobjects < numobjects) {
maxobjects = numobjects;
}
objlist = new Type[maxobjects];
objlist = new Type[maxobjects];
for ( i = 0; i < numobjects; i++ ) {
objlist[i] = temp[i];
}
for (i = 0; i < numobjects; i++) {
objlist[i] = temp[i];
}
delete[] temp;
}
delete[] temp;
}
}
template< class Type >
void Container<Type>::SetObjectAt( int index, const Type& obj )
template<class Type>
void Container<Type>::SetObjectAt(int index, const Type& obj)
{
if ( !objlist )
return;
if (!objlist) {
return;
}
if( ( index <= 0 ) || ( index > numobjects ) ) {
CONTAINER_Error( ERR_DROP, "Container::SetObjectAt : index out of range" );
}
if ((index <= 0) || (index > numobjects)) {
CONTAINER_Error(ERR_DROP,
"Container::SetObjectAt : index out of range");
}
objlist[index - 1] = obj;
objlist[index - 1] = obj;
}
template< class Type >
void Container<Type>::Sort( int( *compare )( const void *elem1, const void *elem2 ) )
template<class Type>
void Container<Type>::Sort(int (*compare)(const void* elem1, const void* elem2))
{
if ( !objlist ) {
return;
}
if (!objlist) {
return;
}
qsort( ( void * )objlist, ( size_t )numobjects, sizeof( Type ), compare );
qsort((void*)objlist, (size_t)numobjects, sizeof(Type), compare);
}
template< class Type >
Type& Container<Type>::operator[]( const int index ) const
template<class Type>
Type& Container<Type>::operator[](const int index) const
{
return ObjectAt( index + 1 );
return ObjectAt(index + 1);
}
template< class Type >
void Container<Type>::Copy( const Container<Type>& container )
template<class Type>
void Container<Type>::Copy(const Container<Type>& container)
{
int i;
int i;
if( &container == this ) {
return;
}
if (&container == this) {
return;
}
FreeObjectList();
FreeObjectList();
numobjects = container.numobjects;
maxobjects = container.maxobjects;
objlist = NULL;
numobjects = container.numobjects;
maxobjects = container.maxobjects;
objlist = NULL;
if( container.objlist == NULL || !container.maxobjects ) {
return;
}
if (container.objlist == NULL || !container.maxobjects) {
return;
}
Resize( maxobjects );
Resize(maxobjects);
if( !container.numobjects ) {
return;
}
if (!container.numobjects) {
return;
}
for( i = 0; i < container.numobjects; i++ ) {
objlist[ i ] = container.objlist[ i ];
}
for (i = 0; i < container.numobjects; i++) {
objlist[i] = container.objlist[i];
}
return;
return;
}
template< class Type >
Container<Type>& Container<Type>::operator=( const Container<Type>& container )
template<class Type>
Container<Type>& Container<Type>::operator=(const Container<Type>& container)
{
Copy( container );
Copy(container);
return *this;
return *this;
}
#endif /* __CONTAINER_H__ */

69
code/qcommon/containerclass.h
View file

@ -26,34 +26,53 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "container.h"
template< class Type >
class ContainerClass : public Class {
Container< Type > value;
template<class Type>
class ContainerClass : public Class
{
Container<Type> value;
public:
virtual ~ContainerClass() { value.FreeObjectList(); }
virtual ~ContainerClass() { value.FreeObjectList(); }
virtual void Archive( Archiver& arc );
virtual void Archive(Archiver& arc);
int AddObject( const Type& obj ) { return value.AddObject( obj ); }
int AddUniqueObject( const Type& obj ) { return value.AddUniqueObject( obj ); }
void AddObjectAt( int index, const Type& obj ) { return value.AddObjectAt( index, obj ); }
Type *AddressOfObjectAt( int index ) { return value.AddressOfObjectAt( index ); }
int AddObject(const Type& obj) { return value.AddObject(obj); }
int AddUniqueObject(const Type& obj) { return value.AddUniqueObject(obj); }
void AddObjectAt(int index, const Type& obj)
{
return value.AddObjectAt(index, obj);
}
Type* AddressOfObjectAt(int index)
{
return value.AddressOfObjectAt(index);
}
void ClearObjectList( void ) { return value.ClearObjectList(); }
void Fix( void ) { return value.Fix(); }
void FreeObjectList( void ) { return value.FreeObjectList(); }
int IndexOfObject( const Type& obj ) { return value.IndexOfObject( obj ); }
void InsertObjectAt( int index, const Type& obj ) { return value.InsertObjectAt( index, obj ); }
int NumObjects( void ) const { return value.NumObjects(); }
Type& ObjectAt( const size_t index ) const { return value.ObjectAt( index ); }
bool ObjectInList( const Type& obj ) { return value.ObjectInList( obj ); }
void RemoveObjectAt( int index ) { return value.RemoveObjectAt( index ); }
void RemoveObject( const Type& obj ) { return value.RemoveObject( obj ); }
void Reset( void ) { return value.Reset(); }
void Resize( int maxelements ) { return value.Resize( maxelements ); }
void SetObjectAt( int index, const Type& obj ) { return value.SetObjectAt( index, obj ); }
void Sort( int( *compare )( const void *elem1, const void *elem2 ) ) { return value.Sort( compare ); }
Type& operator[]( const int index ) const { return value[ index ]; }
Container<Type>& operator=( const Container<Type>& container ) { return value = container; }
void ClearObjectList(void) { return value.ClearObjectList(); }
void Fix(void) { return value.Fix(); }
void FreeObjectList(void) { return value.FreeObjectList(); }
int IndexOfObject(const Type& obj) { return value.IndexOfObject(obj); }
void InsertObjectAt(int index, const Type& obj)
{
return value.InsertObjectAt(index, obj);
}
int NumObjects(void) const { return value.NumObjects(); }
Type& ObjectAt(const size_t index) const { return value.ObjectAt(index); }
bool ObjectInList(const Type& obj) { return value.ObjectInList(obj); }
void RemoveObjectAt(int index) { return value.RemoveObjectAt(index); }
void RemoveObject(const Type& obj) { return value.RemoveObject(obj); }
void Reset(void) { return value.Reset(); }
void Resize(int maxelements) { return value.Resize(maxelements); }
void SetObjectAt(int index, const Type& obj)
{
return value.SetObjectAt(index, obj);
}
void Sort(int (*compare)(const void* elem1, const void* elem2))
{
return value.Sort(compare);
}
Type& operator[](const int index) const { return value[index]; }
Container<Type>& operator=(const Container<Type>& container)
{
return value = container;
}
};

20
code/qcommon/mem_blockalloc.cpp
View file

@ -26,28 +26,16 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "g_local.h"
void *MEM_Alloc( int size )
{
return gi.Malloc( size );
}
void* MEM_Alloc(int size) { return gi.Malloc(size); }
void MEM_Free( void *ptr )
{
return gi.Free( ptr );
}
void MEM_Free(void* ptr) { return gi.Free(ptr); }
#else
#include "qcommon.h"
void* MEM_Alloc(int size)
{
return Z_Malloc(size);
}
void* MEM_Alloc(int size) { return Z_Malloc(size); }
void MEM_Free(void* ptr)
{
return Z_Free(ptr);
}
void MEM_Free(void* ptr) { return Z_Free(ptr); }
#endif

667
code/qcommon/mem_blockalloc.h
View file

@ -31,451 +31,438 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include <type_traits>
#include <new>
void *MEM_Alloc( int size );
void MEM_Free( void *ptr );
void* MEM_Alloc(int size);
void MEM_Free(void* ptr);
static constexpr size_t DefaultBlock = 256;
enum class alloc_source_e
{
SourceBlock = 174,
SourceMalloc
};
enum class alloc_source_e { SourceBlock = 174, SourceMalloc };
template<typename aclass, size_t blocksize>
class MEM_BlockAlloc_enum;
template<typename aclass, size_t blocksize>
class block_s {
class block_s
{
private:
static constexpr size_t bitsNeeded =
blocksize <= 0x80 ? 8 :
blocksize <= 0x8000 ? 16 :
blocksize <= 0x80000000 ? 32 :
64;
static constexpr size_t bitsNeeded = blocksize <= 0x80 ? 8
: blocksize <= 0x8000 ? 16
: blocksize <= 0x80000000 ? 32
: 64;
public:
block_s();
block_s();
#if !_DEBUG_MEMBLOCK
bool usedDataAvailable() const;
bool freeDataAvailable() const;
bool usedDataAvailable() const;
bool freeDataAvailable() const;
#endif
public:
template<size_t bits>
struct selectType_t;
template<size_t bits>
struct selectType_t;
template<> struct selectType_t<8> { using type = uint8_t; };
template<> struct selectType_t<16> { using type = uint16_t; };
template<> struct selectType_t<32> { using type = uint32_t; };
template<> struct selectType_t<64> { using type = uint64_t; };
template<>
struct selectType_t<8> {
using type = uint8_t;
};
template<>
struct selectType_t<16> {
using type = uint16_t;
};
template<>
struct selectType_t<32> {
using type = uint32_t;
};
template<>
struct selectType_t<64> {
using type = uint64_t;
};
using offset_t = typename selectType_t<bitsNeeded>::type;
using offset_t = typename selectType_t<bitsNeeded>::type;
struct info_t {
offset_t index;
alloc_source_e source;
static constexpr uint16_t typeSize = sizeof(aclass);
alignas(alignof(aclass)) char data[sizeof(aclass)];
};
struct info_t {
offset_t index;
alloc_source_e source;
static constexpr uint16_t typeSize = sizeof(aclass);
alignas(alignof(aclass)) char data[sizeof(aclass)];
};
public:
#if !_DEBUG_MEMBLOCK
info_t data[blocksize];
offset_t prev_data[blocksize];
offset_t next_data[blocksize];
info_t data[blocksize];
offset_t prev_data[blocksize];
offset_t next_data[blocksize];
offset_t free_data;
offset_t used_data;
bool has_free_data : 1;
bool has_used_data : 1;
offset_t free_data;
offset_t used_data;
bool has_free_data : 1;
bool has_used_data : 1;
#else
offset_t data[sizeof(aclass)];
offset_t data[sizeof(aclass)];
#endif
block_s<aclass, blocksize>* prev_block;
block_s<aclass, blocksize>* next_block;
block_s<aclass, blocksize>* prev_block;
block_s<aclass, blocksize>* next_block;
public:
static constexpr size_t headersize = offsetof(info_t, data);
static constexpr size_t dataoffset = 0;
static constexpr size_t datasize = sizeof(info_t);
static constexpr size_t headersize = offsetof(info_t, data);
static constexpr size_t dataoffset = 0;
static constexpr size_t datasize = sizeof(info_t);
};
template<typename aclass, size_t blocksize>
block_s<aclass, blocksize>::block_s()
#if !_DEBUG_MEMBLOCK
{
info_t* header;
offset_t curr;
for (curr = 0; curr < blocksize - 1; ++curr)
{
offset_t next = curr + 1;
header = &data[curr];
header->source = alloc_source_e::SourceBlock;
header->index = curr;
prev_data[next] = curr;
next_data[curr] = next;
}
info_t* header;
offset_t curr;
for (curr = 0; curr < blocksize - 1; ++curr) {
offset_t next = curr + 1;
header = &data[curr];
header->source = alloc_source_e::SourceBlock;
header->index = curr;
prev_data[next] = curr;
next_data[curr] = next;
}
header = &data[curr];
header->source = alloc_source_e::SourceBlock;
header->index = blocksize - 1;
prev_data[0] = blocksize - 1;
next_data[blocksize - 1] = 0;
free_data = 0;
prev_block = next_block = nullptr;
header = &data[curr];
header->source = alloc_source_e::SourceBlock;
header->index = blocksize - 1;
prev_data[0] = blocksize - 1;
next_data[blocksize - 1] = 0;
free_data = 0;
prev_block = next_block = nullptr;
has_free_data = true;
has_used_data = false;
has_free_data = true;
has_used_data = false;
}
#else
: prev_block(nullptr)
, next_block(nullptr)
{
}
: prev_block(nullptr), next_block(nullptr)
{}
#endif
#if !_DEBUG_MEMBLOCK
template<typename aclass, size_t blocksize>
bool block_s<aclass, blocksize>::usedDataAvailable() const {
return has_used_data;
bool block_s<aclass, blocksize>::usedDataAvailable() const
{
return has_used_data;
}
template<typename aclass, size_t blocksize>
bool block_s<aclass, blocksize>::freeDataAvailable() const {
return has_free_data;
bool block_s<aclass, blocksize>::freeDataAvailable() const
{
return has_free_data;
}
#endif
template<typename aclass, size_t blocksize = DefaultBlock>
class MEM_BlockAlloc
{
static_assert(blocksize >= 2, "Minimum 2x class preallocation required!!");
public:
MEM_BlockAlloc();
~MEM_BlockAlloc();
static_assert(blocksize >= 2, "Minimum 2x class preallocation required!!");
void* Alloc();
void Free(void* ptr) noexcept;
void FreeAll() noexcept;
size_t Count();
size_t BlockCount();
size_t BlockMemory();
public:
MEM_BlockAlloc();
~MEM_BlockAlloc();
void* Alloc();
void Free(void* ptr) noexcept;
void FreeAll() noexcept;
size_t Count();
size_t BlockCount();
size_t BlockMemory();
private:
friend class MEM_BlockAlloc_enum<aclass, blocksize>;
using block_t = block_s<aclass, blocksize>;
using block_offset_t = typename block_t::offset_t;
friend class MEM_BlockAlloc_enum<aclass, blocksize>;
using block_t = block_s<aclass, blocksize>;
using block_offset_t = typename block_t::offset_t;
#if !_DEBUG_MEMBLOCK
block_t* m_FreeBlock;
block_t* m_StartUsedBlock;
block_t* m_StartFullBlock;
block_t* m_FreeBlock;
block_t* m_StartUsedBlock;
block_t* m_StartFullBlock;
#else
block_t* m_Block;
block_t* m_Block;
#endif
size_t m_BlockCount;
size_t m_BlockCount;
private:
void* TakeFree(block_t* block, uintptr_t free_data);
size_t Count(const block_t* block);
void* TakeFree(block_t* block, uintptr_t free_data);
size_t Count(const block_t* block);
};
template<typename aclass, size_t blocksize = DefaultBlock>
class MEM_BlockAlloc_enum
{
public:
MEM_BlockAlloc_enum(MEM_BlockAlloc<aclass, blocksize>& owner);
MEM_BlockAlloc_enum(MEM_BlockAlloc<aclass, blocksize>& owner);
aclass* NextElement();
aclass* CurrentElement();
aclass* NextElement();
aclass* CurrentElement();
enum blockType_e {
used,
full
};
enum blockType_e { used, full };
private:
using block_t = block_s<aclass, blocksize>;
using offset_t = typename block_t::offset_t;
using block_t = block_s<aclass, blocksize>;
using offset_t = typename block_t::offset_t;
MEM_BlockAlloc<aclass, blocksize>* m_Owner;
block_t* m_CurrentBlock;
MEM_BlockAlloc<aclass, blocksize>* m_Owner;
block_t* m_CurrentBlock;
#if !_DEBUG_MEMBLOCK
offset_t m_CurrentData;
blockType_e m_CurrentBlockType;
offset_t m_CurrentData;
blockType_e m_CurrentBlockType;
#endif
};
template<typename a, size_t b>
MEM_BlockAlloc<a, b>::MEM_BlockAlloc()
#if !_DEBUG_MEMBLOCK
: m_StartUsedBlock()
, m_StartFullBlock()
: m_StartUsedBlock(), m_StartFullBlock()
{
m_FreeBlock = nullptr;
m_BlockCount = 0;
m_FreeBlock = nullptr;
m_BlockCount = 0;
}
#else
: m_Block()
: m_Block()
{
m_BlockCount = 0;
m_BlockCount = 0;
}
#endif
template<typename a, size_t b>
MEM_BlockAlloc<a, b>::~MEM_BlockAlloc()
{
FreeAll();
FreeAll();
}
template<typename a, size_t b>
void* MEM_BlockAlloc<a, b>::Alloc()
{
#if _DEBUG_MEMBLOCK
block_t* block = new(MEM_Alloc(sizeof(block_t))) block_t();
block_t* block = new (MEM_Alloc(sizeof(block_t))) block_t();
m_Block.AddFirst(block);
m_Block.AddFirst(block);
m_BlockCount++;
return (void*)block->data;
m_BlockCount++;
return (void*)block->data;
#else
block_t* used_block;
block_offset_t free_data;
block_offset_t next_data;
block_t* used_block;
block_offset_t free_data;
block_offset_t next_data;
if (m_StartUsedBlock)
{
used_block = m_StartUsedBlock;
if (m_StartUsedBlock) {
used_block = m_StartUsedBlock;
free_data = used_block->free_data;
next_data = used_block->next_data[free_data];
free_data = used_block->free_data;
next_data = used_block->next_data[free_data];
if (next_data == free_data)
{
// Move the block to the next block list as there is no space available
m_StartUsedBlock = used_block->next_block;
if (next_data == free_data) {
// Move the block to the next block list as there is no space
// available
m_StartUsedBlock = used_block->next_block;
LL_SafeRemoveRoot(m_StartUsedBlock, used_block, next_block, prev_block);
LL_SafeAddFirst(m_StartFullBlock, used_block, next_block, prev_block);
LL_SafeRemoveRoot(m_StartUsedBlock, used_block, next_block,
prev_block);
LL_SafeAddFirst(m_StartFullBlock, used_block, next_block,
prev_block);
used_block->has_free_data = false;
return TakeFree(used_block, free_data);
}
}
else
{
if (m_FreeBlock)
{
// start from the free block
used_block = m_FreeBlock;
m_FreeBlock = nullptr;
free_data = used_block->free_data;
next_data = used_block->next_data[free_data];
}
else
{
m_BlockCount++;
// allocate and construct a new block
used_block = new(MEM_Alloc(sizeof(block_t))) block_t();
used_block->has_free_data = false;
return TakeFree(used_block, free_data);
}
} else {
if (m_FreeBlock) {
// start from the free block
used_block = m_FreeBlock;
m_FreeBlock = nullptr;
free_data = used_block->free_data;
next_data = used_block->next_data[free_data];
} else {
m_BlockCount++;
// allocate and construct a new block
used_block = new (MEM_Alloc(sizeof(block_t))) block_t();
free_data = 0;
next_data = 1;
}
free_data = 0;
next_data = 1;
}
LL_SafeAddFirst(m_StartUsedBlock, used_block, next_block, prev_block);
}
LL_SafeAddFirst(m_StartUsedBlock, used_block, next_block, prev_block);
}
const block_offset_t prev_data = used_block->prev_data[free_data];
const block_offset_t prev_data = used_block->prev_data[free_data];
used_block->next_data[prev_data] = next_data;
used_block->prev_data[next_data] = prev_data;
used_block->free_data = next_data;
used_block->has_free_data = true;
used_block->next_data[prev_data] = next_data;
used_block->prev_data[next_data] = prev_data;
used_block->free_data = next_data;
used_block->has_free_data = true;
if (!used_block->usedDataAvailable())
{
used_block->used_data = free_data;
used_block->has_used_data = true;
used_block->next_data[free_data] = free_data;
used_block->prev_data[free_data] = free_data;
return used_block->data[free_data].data;
}
if (!used_block->usedDataAvailable()) {
used_block->used_data = free_data;
used_block->has_used_data = true;
used_block->next_data[free_data] = free_data;
used_block->prev_data[free_data] = free_data;
return used_block->data[free_data].data;
}
return TakeFree(used_block, free_data);
return TakeFree(used_block, free_data);
#endif
}
template< typename aclass, size_t blocksize>
void* MEM_BlockAlloc<aclass, blocksize>::TakeFree(block_t* block, uintptr_t free_data)
template<typename aclass, size_t blocksize>
void* MEM_BlockAlloc<aclass, blocksize>::TakeFree(block_t* block,
uintptr_t free_data)
{
const block_offset_t used_data = block->used_data;
const block_offset_t prev_data = block->prev_data[used_data];
const block_offset_t used_data = block->used_data;
const block_offset_t prev_data = block->prev_data[used_data];
block->next_data[prev_data] = (block_offset_t)free_data;
block->prev_data[used_data] = (block_offset_t)free_data;
block->next_data[free_data] = used_data;
block->prev_data[free_data] = prev_data;
return block->data[free_data].data;
block->next_data[prev_data] = (block_offset_t)free_data;
block->prev_data[used_data] = (block_offset_t)free_data;
block->next_data[free_data] = used_data;
block->prev_data[free_data] = prev_data;
return block->data[free_data].data;
}
template<typename a, size_t b>
void MEM_BlockAlloc<a, b>::Free(void* ptr) noexcept
{
#if _DEBUG_MEMBLOCK
block_s<a, b>* block = (block_s<a, b> *)ptr;
block_s<a, b>* block = (block_s<a, b>*)ptr;
m_Block.Remove(block);
m_Block.Remove(block);
m_BlockCount--;
MEM::Free(block);
m_BlockCount--;
MEM::Free(block);
#else
// get the header of the pointer
typename block_t::info_t* header = reinterpret_cast<typename block_t::info_t*>(static_cast<unsigned char*>(ptr) - block_t::headersize);
const block_offset_t used_data = header->index;
// get the block from the header
block_t* const block = (block_t*)((uint8_t*)header - used_data * block_t::datasize - block_t::dataoffset);
const block_offset_t next_data = block->next_data[used_data];
if (next_data == used_data)
{
LL_SafeRemoveRoot(m_StartUsedBlock, block, next_block, prev_block);
// get the header of the pointer
typename block_t::info_t* header =
reinterpret_cast<typename block_t::info_t*>(
static_cast<unsigned char*>(ptr) - block_t::headersize);
const block_offset_t used_data = header->index;
// get the block from the header
block_t* const block =
(block_t*)((uint8_t*)header - used_data * block_t::datasize -
block_t::dataoffset);
const block_offset_t next_data = block->next_data[used_data];
if (next_data == used_data) {
LL_SafeRemoveRoot(m_StartUsedBlock, block, next_block, prev_block);
if (m_FreeBlock)
{
// deallocate the free block because of another deallocation
--m_BlockCount;
MEM_Free(m_FreeBlock);
m_FreeBlock = nullptr;
}
if (m_FreeBlock) {
// deallocate the free block because of another deallocation
--m_BlockCount;
MEM_Free(m_FreeBlock);
m_FreeBlock = nullptr;
}
m_FreeBlock = block;
block->has_used_data = false;
m_FreeBlock = block;
block->has_used_data = false;
const block_offset_t free_data = block->free_data;
const block_offset_t prev_data = block->prev_data[free_data];
const block_offset_t free_data = block->free_data;
const block_offset_t prev_data = block->prev_data[free_data];
block->next_data[prev_data] = used_data;
block->prev_data[free_data] = used_data;
block->next_data[used_data] = free_data;
block->prev_data[used_data] = prev_data;
}
else
{
const block_offset_t prev_data = block->prev_data[used_data];
block->next_data[prev_data] = used_data;
block->prev_data[free_data] = used_data;
block->next_data[used_data] = free_data;
block->prev_data[used_data] = prev_data;
} else {
const block_offset_t prev_data = block->prev_data[used_data];
block->next_data[prev_data] = next_data;
block->prev_data[next_data] = prev_data;
block->used_data = next_data;
block->has_used_data = true;
block->next_data[prev_data] = next_data;
block->prev_data[next_data] = prev_data;
block->used_data = next_data;
block->has_used_data = true;
if (block->freeDataAvailable())
{
const block_offset_t free_data = block->free_data;
const block_offset_t prev_data = block->prev_data[free_data];
if (block->freeDataAvailable()) {
const block_offset_t free_data = block->free_data;
const block_offset_t prev_data = block->prev_data[free_data];
block->next_data[prev_data] = used_data;
block->prev_data[free_data] = used_data;
block->next_data[used_data] = free_data;
block->prev_data[used_data] = prev_data;
return;
}
block->next_data[prev_data] = used_data;
block->prev_data[free_data] = used_data;
block->next_data[used_data] = free_data;
block->prev_data[used_data] = prev_data;
return;
}
if (m_StartFullBlock == block)
{
m_StartFullBlock = block->next_block;
}
if (m_StartFullBlock == block) {
m_StartFullBlock = block->next_block;
}
LL_SafeRemoveRoot(m_StartFullBlock, block, next_block, prev_block);
LL_SafeAddFirst(m_StartUsedBlock, block, next_block, prev_block);
LL_SafeRemoveRoot(m_StartFullBlock, block, next_block, prev_block);
LL_SafeAddFirst(m_StartUsedBlock, block, next_block, prev_block);
block->free_data = used_data;
block->has_free_data = true;
block->prev_data[used_data] = used_data;
block->next_data[used_data] = used_data;
}
block->free_data = used_data;
block->has_free_data = true;
block->prev_data[used_data] = used_data;
block->next_data[used_data] = used_data;
}
#endif
}
template<typename a, size_t b>
void MEM_BlockAlloc<a, b>::FreeAll() noexcept
{
block_t* block;
block_t* block;
#if _DEBUG_MEMBLOCK
block_t* next = m_Block.Root();
for (block = next; block; block = next)
{
next = block->next_block;
m_BlockCount--;
a* ptr = (a*)block->data;
ptr->~a();
MEM::Free(block);
}
m_Block.Reset();
block_t* next = m_Block.Root();
for (block = next; block; block = next) {
next = block->next_block;
m_BlockCount--;
a* ptr = (a*)block->data;
ptr->~a();
MEM::Free(block);
}
m_Block.Reset();
#else
while((block = m_StartFullBlock) != nullptr)
{
if (block->usedDataAvailable())
{
a* ptr = (a*)block->data[block->used_data].data;
ptr->~a();
Free(ptr);
block = m_StartFullBlock;
}
}
while ((block = m_StartFullBlock) != nullptr) {
if (block->usedDataAvailable()) {
a* ptr = (a*)block->data[block->used_data].data;
ptr->~a();
Free(ptr);
block = m_StartFullBlock;
}
}
while ((block = m_StartUsedBlock) != nullptr)
{
if (block->usedDataAvailable())
{
a* ptr = (a*)block->data[block->used_data].data;
ptr->~a();
Free(ptr);
}
}
while ((block = m_StartUsedBlock) != nullptr) {
if (block->usedDataAvailable()) {
a* ptr = (a*)block->data[block->used_data].data;
ptr->~a();
Free(ptr);
}
}
if (m_FreeBlock)
{
m_BlockCount--;
MEM_Free(m_FreeBlock);
m_FreeBlock = nullptr;
}
if (m_FreeBlock) {
m_BlockCount--;
MEM_Free(m_FreeBlock);
m_FreeBlock = nullptr;
}
#endif
}
template<typename a, size_t b>
size_t MEM_BlockAlloc<a, b>::Count(const block_t* list)
{
int count = 0;
int count = 0;
#if _DEBUG_MEMBLOCK
for (const block_t* block = list; block; block = block->next_block)
{
count++;
}
return count;
for (const block_t* block = list; block; block = block->next_block) {
count++;
}
return count;
#else
for (const block_t* block = list; block; block = block->next_block)
{
if (!block->usedDataAvailable())
{
continue;
}
for (const block_t* block = list; block; block = block->next_block) {
if (!block->usedDataAvailable()) {
continue;
}
const block_offset_t used_data = block->used_data;
block_offset_t current_used_data = used_data;
const block_offset_t used_data = block->used_data;
block_offset_t current_used_data = used_data;
do
{
count++;
current_used_data = block->next_data[current_used_data];
} while (current_used_data != used_data);
}
do {
count++;
current_used_data = block->next_data[current_used_data];
} while (current_used_data != used_data);
}
return count;
return count;
#endif
}
@ -483,32 +470,31 @@ template<typename a, size_t b>
size_t MEM_BlockAlloc<a, b>::Count()
{
#if _DEBUG_MEMBLOCK
return Count(m_Block);
return Count(m_Block);
#else
return Count(m_StartFullBlock) + Count(m_StartUsedBlock);
return Count(m_StartFullBlock) + Count(m_StartUsedBlock);
#endif
}
template<typename a, size_t b>
size_t MEM_BlockAlloc<a, b>::BlockCount()
{
return m_BlockCount;
return m_BlockCount;
}
template<typename a, size_t b>
size_t MEM_BlockAlloc<a, b>::BlockMemory()
{
return sizeof(block_s<a, b>);
return sizeof(block_s<a, b>);
}
template<typename a, size_t b>
MEM_BlockAlloc_enum<a, b >::MEM_BlockAlloc_enum(MEM_BlockAlloc< a, b>& owner)
MEM_BlockAlloc_enum<a, b>::MEM_BlockAlloc_enum(MEM_BlockAlloc<a, b>& owner)
{
m_Owner = &owner;
m_CurrentBlock = nullptr;
m_Owner = &owner;
m_CurrentBlock = nullptr;
#if !_DEBUG_MEMBLOCK
m_CurrentBlockType = MEM_BlockAlloc_enum::used;
m_CurrentBlockType = MEM_BlockAlloc_enum::used;
#endif
}
@ -516,71 +502,64 @@ template<typename a, size_t b>
a* MEM_BlockAlloc_enum<a, b>::NextElement()
{
#if _DEBUG_MEMBLOCK
if (!m_CurrentBlock)
{
m_CurrentBlock = m_Owner->m_Block.Root();
}
else
{
m_CurrentBlock = m_CurrentBlock->next_block;
}
return (a*)m_CurrentBlock;
if (!m_CurrentBlock) {
m_CurrentBlock = m_Owner->m_Block.Root();
} else {
m_CurrentBlock = m_CurrentBlock->next_block;
}
return (a*)m_CurrentBlock;
#else
// search for a valid block type
while (!m_CurrentBlock)
{
switch (m_CurrentBlockType)
{
case blockType_e::used:
m_CurrentBlock = m_Owner->m_StartUsedBlock;
break;
case blockType_e::full:
m_CurrentBlock = m_Owner->m_StartFullBlock;
break;
default:
return nullptr;
}
// search for a valid block type
while (!m_CurrentBlock) {
switch (m_CurrentBlockType) {
case blockType_e::used:
m_CurrentBlock = m_Owner->m_StartUsedBlock;
break;
case blockType_e::full:
m_CurrentBlock = m_Owner->m_StartFullBlock;
break;
default:
return nullptr;
}
reinterpret_cast<uint8_t&>(m_CurrentBlockType)++;
reinterpret_cast<uint8_t&>(m_CurrentBlockType)++;
_label:
for (; m_CurrentBlock; m_CurrentBlock = m_CurrentBlock->next_block)
{
if (m_CurrentBlock->usedDataAvailable())
{
m_CurrentData = m_CurrentBlock->used_data;
return reinterpret_cast<a*>(m_CurrentBlock->data[m_CurrentData].data);
}
}
}
_label:
for (; m_CurrentBlock; m_CurrentBlock = m_CurrentBlock->next_block) {
if (m_CurrentBlock->usedDataAvailable()) {
m_CurrentData = m_CurrentBlock->used_data;
return reinterpret_cast<a*>(
m_CurrentBlock->data[m_CurrentData].data);
}
}
}
m_CurrentData = m_CurrentBlock->next_data[m_CurrentData];
m_CurrentData = m_CurrentBlock->next_data[m_CurrentData];
if (m_CurrentData == m_CurrentBlock->used_data)
{
// found an object
m_CurrentBlock = m_CurrentBlock->next_block;
goto _label;
}
if (m_CurrentData == m_CurrentBlock->used_data) {
// found an object
m_CurrentBlock = m_CurrentBlock->next_block;
goto _label;
}
return reinterpret_cast<a*>(m_CurrentBlock->data[m_CurrentData].data);
return reinterpret_cast<a*>(m_CurrentBlock->data[m_CurrentData].data);
#endif
}
template<typename a, size_t b>
a* MEM_BlockAlloc_enum<a, b>::CurrentElement()
{
return m_CurrentBlock;
return m_CurrentBlock;
}
template<typename a, size_t b>
void* operator new(size_t, MEM_BlockAlloc<a, b>& allocator)
{
return allocator.Alloc();
return allocator.Alloc();
}
template<typename a, size_t b>
void operator delete(void* ptr, MEM_BlockAlloc<a, b>& allocator) noexcept
{
return allocator.Free(ptr);
return allocator.Free(ptr);
}

99
code/qcommon/mem_tempalloc.cpp
View file

@ -28,94 +28,83 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "g_local.h"
#define MEM_TempAllocate(x) gi.Malloc(x)
#define MEM_TempFree(x) gi.Free(x)
#define MEM_TempFree(x) gi.Free(x)
#else
#include "qcommon.h"
#define MEM_TempAllocate(x) Z_Malloc(x)
#define MEM_TempFree(x) Z_Free(x)
#define MEM_TempFree(x) Z_Free(x)
#endif
class tempBlock_t
{
public:
void* GetData();
void* GetData(size_t pos);
void* GetData();
void* GetData(size_t pos);
public:
tempBlock_t* prev;
tempBlock_t* prev;
};
MEM_TempAlloc::MEM_TempAlloc()
{
m_CurrentMemoryBlock = nullptr;
m_CurrentMemoryPos = 0;
m_BlockSize = 0;
m_LastPos = 0;
m_CurrentMemoryBlock = nullptr;
m_CurrentMemoryPos = 0;
m_BlockSize = 0;
m_LastPos = 0;
}
void* MEM_TempAlloc::Alloc(size_t len)
{
if (m_CurrentMemoryBlock && m_CurrentMemoryPos + len <= m_BlockSize)
{
void* data = m_CurrentMemoryBlock->GetData(m_CurrentMemoryPos);
m_LastPos = m_CurrentMemoryPos;
m_CurrentMemoryPos += len;
return data;
}
else
{
return CreateBlock(len);
}
if (m_CurrentMemoryBlock && m_CurrentMemoryPos + len <= m_BlockSize) {
void* data = m_CurrentMemoryBlock->GetData(m_CurrentMemoryPos);
m_LastPos = m_CurrentMemoryPos;
m_CurrentMemoryPos += len;
return data;
} else {
return CreateBlock(len);
}
}
void* MEM_TempAlloc::Alloc(size_t len, size_t alignment)
{
if (m_CurrentMemoryBlock)
{
if (m_CurrentMemoryPos % alignment != 0) {
m_CurrentMemoryPos += alignment - m_CurrentMemoryPos % alignment;
}
if (m_CurrentMemoryBlock) {
if (m_CurrentMemoryPos % alignment != 0) {
m_CurrentMemoryPos += alignment - m_CurrentMemoryPos % alignment;
}
if (m_CurrentMemoryPos + len <= m_BlockSize)
{
void* data = m_CurrentMemoryBlock->GetData(m_CurrentMemoryPos);
m_LastPos = m_CurrentMemoryPos;
m_CurrentMemoryPos += len;
return data;
}
}
if (m_CurrentMemoryPos + len <= m_BlockSize) {
void* data = m_CurrentMemoryBlock->GetData(m_CurrentMemoryPos);
m_LastPos = m_CurrentMemoryPos;
m_CurrentMemoryPos += len;
return data;
}
}
return CreateBlock(len);
return CreateBlock(len);
}
void MEM_TempAlloc::FreeAll( void )
void MEM_TempAlloc::FreeAll(void)
{
while (m_CurrentMemoryBlock)
{
tempBlock_t* prev_block = m_CurrentMemoryBlock->prev;
MEM_TempFree(m_CurrentMemoryBlock);
m_CurrentMemoryBlock = prev_block;
}
while (m_CurrentMemoryBlock) {
tempBlock_t* prev_block = m_CurrentMemoryBlock->prev;
MEM_TempFree(m_CurrentMemoryBlock);
m_CurrentMemoryBlock = prev_block;
}
}
void* MEM_TempAlloc::CreateBlock(size_t len)
{
m_CurrentMemoryPos = len;
m_CurrentMemoryPos = len;
// allocate a new block
tempBlock_t* prev_block = m_CurrentMemoryBlock;
m_CurrentMemoryBlock = (tempBlock_t*)MEM_TempAllocate(sizeof(tempBlock_t) + max(m_BlockSize, len));
m_CurrentMemoryBlock->prev = prev_block;
return m_CurrentMemoryBlock->GetData();
// allocate a new block
tempBlock_t* prev_block = m_CurrentMemoryBlock;
m_CurrentMemoryBlock = (tempBlock_t*)MEM_TempAllocate(
sizeof(tempBlock_t) + max(m_BlockSize, len));
m_CurrentMemoryBlock->prev = prev_block;
return m_CurrentMemoryBlock->GetData();
}
void* tempBlock_t::GetData()
{
return (void*)(this + 1);
}
void* tempBlock_t::GetData() { return (void*)(this + 1); }
void* tempBlock_t::GetData(size_t pos)
{
return (uint8_t*)(this + 1) + pos;
}
void* tempBlock_t::GetData(size_t pos) { return (uint8_t*)(this + 1) + pos; }

23
code/qcommon/mem_tempalloc.h
View file

@ -28,19 +28,20 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
class tempBlock_t;
class MEM_TempAlloc {
class MEM_TempAlloc
{
public:
MEM_TempAlloc();
MEM_TempAlloc();
void* Alloc(size_t len);
void* Alloc(size_t len, size_t alignment);
void FreeAll(void);
// This was added to fix issues with alignment
void* CreateBlock(size_t len);
void* Alloc(size_t len);
void* Alloc(size_t len, size_t alignment);
void FreeAll(void);
// This was added to fix issues with alignment
void* CreateBlock(size_t len);
private:
tempBlock_t* m_CurrentMemoryBlock;
size_t m_CurrentMemoryPos;
size_t m_BlockSize;
size_t m_LastPos;
tempBlock_t* m_CurrentMemoryBlock;
size_t m_CurrentMemoryPos;
size_t m_BlockSize;
size_t m_LastPos;
};

1446
code/qcommon/script.cpp
View file

File diff suppressed because it is too large Load diff

238
code/qcommon/script.h
View file

@ -33,156 +33,148 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "archive.h"
#endif
#define TOKENCOMMENT (';')
#define TOKENCOMMENT2 ('#')
#define TOKENEOL ('\n')
//#define TOKENNULL ('\0')
#define TOKENSPACE (' ')
#define TOKENSPECIAL ('$')
#define TOKENCOMMENT (';')
#define TOKENCOMMENT2 ('#')
#define TOKENEOL ('\n')
// #define TOKENNULL ('\0')
#define TOKENSPACE (' ')
#define TOKENSPECIAL ('$')
#define MAXTOKEN 512
#define MAXTOKEN 512
typedef struct
{
qboolean tokenready;
int offset;
int line;
char token[ MAXTOKEN ];
} scriptmarker_t;
typedef struct {
qboolean tokenready;
int offset;
int line;
char token[MAXTOKEN];
} scriptmarker_t;
typedef struct
{
//const char *macroName;
//const char *macroText;
str macroName;
str macroText;
} macro;
typedef struct {
// const char *macroName;
// const char *macroText;
str macroName;
str macroText;
} macro;
class Script : public Class
{
protected:
qboolean tokenready;
{
protected:
qboolean tokenready;
str filename;
const char *script_p;
const char *end_p;
Container<macro *> macrolist;
str filename;
const char* script_p;
const char* end_p;
Container<macro*> macrolist;
int line;
char token[ MAXTOKEN ];
int line;
char token[MAXTOKEN];
qboolean releaseBuffer;
qboolean hasError;
qboolean releaseBuffer;
qboolean hasError;
qboolean AtComment( void );
void CheckOverflow( void );
qboolean AtComment(void);
void CheckOverflow(void);
public:
const char *buffer;
size_t length;
public:
const char* buffer;
size_t length;
CLASS_PROTOTYPE( Script );
CLASS_PROTOTYPE(Script);
#if defined(ARCHIVE_SUPPORTED)
void Archive( Archiver &arc ) override;
void Archive(Archiver& arc) override;
#endif
~Script();
Script( const char* filename );
Script();
~Script();
Script(const char* filename);
Script();
void Close( void );
const char *Filename( void );
int GetLineNumber( void );
void Reset( void );
void MarkPosition( scriptmarker_t *mark );
void RestorePosition( const scriptmarker_t *mark );
qboolean SkipToEOL( void );
void SkipWhiteSpace( qboolean crossline );
void SkipNonToken( qboolean crossline );
qboolean TokenAvailable( qboolean crossline );
qboolean CommentAvailable( qboolean crossline );
void UnGetToken( void );
qboolean AtString( qboolean crossline );
qboolean AtOpenParen( qboolean crossline );
qboolean AtCloseParen( qboolean crossline );
qboolean AtComma( qboolean crossline );
qboolean AtDot( qboolean crossline );
qboolean AtAssignment( qboolean crossline );
const char *GetToken( qboolean crossline );
const char *GetLine( qboolean crossline );
const char *GetRaw( void );
const char *GetString( qboolean crossline );
qboolean GetSpecific( const char *string );
qboolean GetBoolean( qboolean crossline );
int GetInteger( qboolean crossline );
double GetDouble( qboolean crossline );
float GetFloat( qboolean crossline );
Vector GetVector( qboolean crossline );
int LinesInFile( void );
void Parse( const char *data, size_t length, const char *name );
void LoadFile( const char *name );
void LoadFile( const char *name, int length, const char *buf );
const char *Token( void );
void AddMacroDefinition( qboolean crossline );
const char *GetMacroString( const char *theMacroName );
char *EvaluateMacroString( const char *theMacroString );
float EvaluateMacroMath(float value, float newval, char oper);
const char *GetExprToken(const char *ptr, char *token);
const char *GrabNextToken( qboolean crossline );
qboolean isMacro( void );
void Close(void);
const char* Filename(void);
int GetLineNumber(void);
void Reset(void);
void MarkPosition(scriptmarker_t* mark);
void RestorePosition(const scriptmarker_t* mark);
qboolean SkipToEOL(void);
void SkipWhiteSpace(qboolean crossline);
void SkipNonToken(qboolean crossline);
qboolean TokenAvailable(qboolean crossline);
qboolean CommentAvailable(qboolean crossline);
void UnGetToken(void);
qboolean AtString(qboolean crossline);
qboolean AtOpenParen(qboolean crossline);
qboolean AtCloseParen(qboolean crossline);
qboolean AtComma(qboolean crossline);
qboolean AtDot(qboolean crossline);
qboolean AtAssignment(qboolean crossline);
const char* GetToken(qboolean crossline);
const char* GetLine(qboolean crossline);
const char* GetRaw(void);
const char* GetString(qboolean crossline);
qboolean GetSpecific(const char* string);
qboolean GetBoolean(qboolean crossline);
int GetInteger(qboolean crossline);
double GetDouble(qboolean crossline);
float GetFloat(qboolean crossline);
Vector GetVector(qboolean crossline);
int LinesInFile(void);
void Parse(const char* data, size_t length, const char* name);
void LoadFile(const char* name);
void LoadFile(const char* name, int length, const char* buf);
const char* Token(void);
void AddMacroDefinition(qboolean crossline);
const char* GetMacroString(const char* theMacroName);
char* EvaluateMacroString(const char* theMacroString);
float EvaluateMacroMath(float value, float newval, char oper);
const char* GetExprToken(const char* ptr, char* token);
const char* GrabNextToken(qboolean crossline);
qboolean isMacro(void);
qboolean EndOfFile();
qboolean isValid( void );
qboolean EndOfFile();
qboolean isValid(void);
Container<macro *> *GetMacroList() { return &macrolist; }
void AddMacro(const char *name, const char *value);
};
Container<macro*>* GetMacroList() { return &macrolist; }
void AddMacro(const char* name, const char* value);
};
#if defined(ARCHIVE_SUPPORTED)
inline void Script::Archive
(
Archiver &arc
)
{
int pos;
inline void Script::Archive(Archiver& arc)
{
int pos;
arc.ArchiveBoolean( &tokenready );
arc.ArchiveBoolean(&tokenready);
arc.ArchiveString( &filename );
if ( arc.Loading() )
{
//
// load the file in
//
LoadFile( filename.c_str() );
}
arc.ArchiveString(&filename);
if (arc.Loading()) {
//
// load the file in
//
LoadFile(filename.c_str());
}
if ( !arc.Loading() )
{
//
// save out current pointer as an offset
//
pos = script_p - buffer;
}
arc.ArchiveInteger( &pos );
if ( arc.Loading() )
{
//
// restore the script pointer
//
script_p = buffer + pos;
}
if (!arc.Loading()) {
//
// save out current pointer as an offset
//
pos = script_p - buffer;
}
arc.ArchiveInteger(&pos);
if (arc.Loading()) {
//
// restore the script pointer
//
script_p = buffer + pos;
}
//const char *end_p;
//Container<macro *> macrolist;
// const char *end_p;
// Container<macro *> macrolist;
arc.ArchiveInteger( &line );
arc.ArchiveRaw( &token, sizeof( token ) );
arc.ArchiveInteger(&line);
arc.ArchiveRaw(&token, sizeof(token));
//qboolean releaseBuffer;
}
// qboolean releaseBuffer;
}
#endif
#endif