diff --git a/code/qcommon/class.h b/code/qcommon/class.h index 3f9f76b9..26e76f77 100644 --- a/code/qcommon/class.h +++ b/code/qcommon/class.h @@ -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 *)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::Responses[] = +#define CLASS_DECLARATION(parentclass, classname, classid) \ + ClassDef classname::ClassInfo(#classname, classid, #parentclass, \ + (ResponseDef*)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::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 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 Responses[] #else -#define CLASS_DECLARATION( parentclass, classname, classid ) \ - ClassDef classname::ClassInfo \ - ( \ - #classname, classid, #parentclass, \ - (ResponseDef *)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::Responses[] = +#define CLASS_DECLARATION(parentclass, classname, classid) \ + ClassDef classname::ClassInfo(#classname, classid, #parentclass, \ + (ResponseDef*)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::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 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 Responses[] #endif -typedef void ( Class::*Response )( Event *ev ); +typedef void (Class::*Response)(Event* ev); class EventDef; -template< class Type > +template 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 *responses; - ResponseDef **responseLookup; - ClassDef *super; - ClassDef *next; - ClassDef *prev; + const char* classname; + const char* classID; + const char* superclass; + void* (*newInstance)(void); + int classSize; + ResponseDef* responses; + ResponseDef** responseLookup; + ClassDef* super; + ClassDef* next; + ClassDef* prev; #ifndef NO_SCRIPTENGINE - con_set *waitTillSet; + con_set* 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 sortedList; + static Container 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* 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 *responses, - void *( *newInstance )( void ), int classSize ); - void CreateInternal( const char *classname, const char *classID, const char *superclass, ResponseDef *responses, - void *( *newInstance )( void ), int classSize ); - void CreateInternalWin( const char *classname, const char *classID, const char *superclass, ResponseDef *responses, - void *( *newInstance )( void ), int classSize ); + /* Create-a-class function */ + ClassDef(const char* classname, const char* classID, const char* superclass, + ResponseDef* responses, void* (*newInstance)(void), + int classSize); + void CreateInternal(const char* classname, const char* classID, + const char* superclass, ResponseDef* responses, + void* (*newInstance)(void), int classSize); + void CreateInternalWin(const char* classname, const char* classID, + const char* superclass, + ResponseDef* 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 *responses ); + /* Hook-a-class function */ + ClassDefHook(ClassDef* classdef, ResponseDef* 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 Responses[]; + static ClassDef ClassInfo; + static ClassDefHook _ClassInfo_; + static void* _newInstance(void); + static ClassDef* classinfostatic(void); + virtual ClassDef* classinfo(void) const; + static ResponseDef 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" diff --git a/code/qcommon/configurator.h b/code/qcommon/configurator.h index cf271225..267b8df9 100644 --- a/code/qcommon/configurator.h +++ b/code/qcommon/configurator.h @@ -27,84 +27,88 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include -#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 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 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 m_sections; + Container 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__ */ diff --git a/code/qcommon/container.h b/code/qcommon/container.h index 0ad68314..4b7fc73e 100644 --- a/code/qcommon/container.h +++ b/code/qcommon/container.h @@ -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 Container { private: - Type *objlist; - int numobjects; - int maxobjects; + Type* objlist; + int numobjects; + int maxobjects; private: - void Copy( const Container& container ); + void Copy(const Container& container); public: - Container(); - Container( const Container& container ); - ~Container(); + Container(); + Container(const Container& 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& operator=( const Container& 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& operator=(const Container& container); }; -template< class Type > +template Container::Container() { - objlist = NULL; - numobjects = 0; - maxobjects = 0; + objlist = NULL; + numobjects = 0; + maxobjects = 0; } -template< class Type > -Container::Container( const Container& container ) +template +Container::Container(const Container& container) { - objlist = NULL; + objlist = NULL; - Copy( container ); + Copy(container); } -template< class Type > +template Container::~Container() { - FreeObjectList(); + FreeObjectList(); } -template< class Type > -int Container::AddObject( const Type& obj ) +template +int Container::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::AddUniqueObject( const Type& obj ) +template +int Container::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::AddObjectAt( int index, const Type& obj ) +template +void Container::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::AddressOfObjectAt( int index ) +template +Type* Container::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::Archive( Archiver &arc ) }*/ -template< class Type > -void Container::ClearObjectList( void ) +template +void Container::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::Fix( void ) +template +void Container::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::FreeObjectList( void ) +template +void Container::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::IndexOfObject( const Type& obj ) +template +int Container::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::InsertObjectAt( int index, const Type& obj ) +template +void Container::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::MaxObjects( void ) const +template +int Container::MaxObjects(void) const { - return maxobjects; + return maxobjects; } -template< class Type > -int Container::NumObjects( void ) const +template +int Container::NumObjects(void) const { - return numobjects; + return numobjects; } -template< class Type > -Type& Container::ObjectAt( const size_t index ) const +template +Type& Container::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::ObjectInList( const Type& obj ) +template +bool Container::ObjectInList(const Type& obj) { - if ( !IndexOfObject( obj ) ) { - return false; - } + if (!IndexOfObject(obj)) { + return false; + } - return true; + return true; } -template< class Type > -void Container::RemoveObjectAt( int index ) +template +void Container::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::RemoveObject( const Type& obj ) +template +void Container::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 void Container::Reset() { - objlist = NULL; - numobjects = 0; - maxobjects = 0; + objlist = NULL; + numobjects = 0; + maxobjects = 0; } -template< class Type > -void Container::Resize( int maxelements ) +template +void Container::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::SetObjectAt( int index, const Type& obj ) +template +void Container::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::Sort( int( *compare )( const void *elem1, const void *elem2 ) ) +template +void Container::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::operator[]( const int index ) const +template +Type& Container::operator[](const int index) const { - return ObjectAt( index + 1 ); + return ObjectAt(index + 1); } -template< class Type > -void Container::Copy( const Container& container ) +template +void Container::Copy(const Container& 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& Container::operator=( const Container& container ) +template +Container& Container::operator=(const Container& container) { - Copy( container ); + Copy(container); - return *this; + return *this; } #endif /* __CONTAINER_H__ */ diff --git a/code/qcommon/containerclass.h b/code/qcommon/containerclass.h index 1b4f843c..98eaaa9c 100644 --- a/code/qcommon/containerclass.h +++ b/code/qcommon/containerclass.h @@ -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 ContainerClass : public Class +{ + Container 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& operator=( const Container& 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& operator=(const Container& container) + { + return value = container; + } }; diff --git a/code/qcommon/mem_blockalloc.cpp b/code/qcommon/mem_blockalloc.cpp index fdf675ef..7bd4ac82 100644 --- a/code/qcommon/mem_blockalloc.cpp +++ b/code/qcommon/mem_blockalloc.cpp @@ -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 diff --git a/code/qcommon/mem_blockalloc.h b/code/qcommon/mem_blockalloc.h index bdcd32b8..e89d636a 100644 --- a/code/qcommon/mem_blockalloc.h +++ b/code/qcommon/mem_blockalloc.h @@ -31,451 +31,438 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include #include -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 class MEM_BlockAlloc_enum; template -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 - struct selectType_t; + template + 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::type; + using offset_t = typename selectType_t::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* prev_block; - block_s* next_block; + block_s* prev_block; + block_s* 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 block_s::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 -bool block_s::usedDataAvailable() const { - return has_used_data; +bool block_s::usedDataAvailable() const +{ + return has_used_data; } template -bool block_s::freeDataAvailable() const { - return has_free_data; +bool block_s::freeDataAvailable() const +{ + return has_free_data; } #endif template 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; - using block_t = block_s; - using block_offset_t = typename block_t::offset_t; + friend class MEM_BlockAlloc_enum; + using block_t = block_s; + 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 class MEM_BlockAlloc_enum { public: - MEM_BlockAlloc_enum(MEM_BlockAlloc& owner); + MEM_BlockAlloc_enum(MEM_BlockAlloc& 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; - using offset_t = typename block_t::offset_t; + using block_t = block_s; + using offset_t = typename block_t::offset_t; - MEM_BlockAlloc* m_Owner; - block_t* m_CurrentBlock; + MEM_BlockAlloc* 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 MEM_BlockAlloc::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 MEM_BlockAlloc::~MEM_BlockAlloc() { - FreeAll(); + FreeAll(); } template void* MEM_BlockAlloc::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::TakeFree(block_t* block, uintptr_t free_data) +template +void* MEM_BlockAlloc::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 void MEM_BlockAlloc::Free(void* ptr) noexcept { #if _DEBUG_MEMBLOCK - block_s* block = (block_s *)ptr; + block_s* block = (block_s*)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(static_cast(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( + static_cast(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 void MEM_BlockAlloc::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 size_t MEM_BlockAlloc::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 size_t MEM_BlockAlloc::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 size_t MEM_BlockAlloc::BlockCount() { - return m_BlockCount; + return m_BlockCount; } template size_t MEM_BlockAlloc::BlockMemory() { - return sizeof(block_s); + return sizeof(block_s); } - template -MEM_BlockAlloc_enum::MEM_BlockAlloc_enum(MEM_BlockAlloc< a, b>& owner) +MEM_BlockAlloc_enum::MEM_BlockAlloc_enum(MEM_BlockAlloc& 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 a* MEM_BlockAlloc_enum::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(m_CurrentBlockType)++; + reinterpret_cast(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(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( + 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(m_CurrentBlock->data[m_CurrentData].data); + return reinterpret_cast(m_CurrentBlock->data[m_CurrentData].data); #endif } template a* MEM_BlockAlloc_enum::CurrentElement() { - return m_CurrentBlock; + return m_CurrentBlock; } template void* operator new(size_t, MEM_BlockAlloc& allocator) { - return allocator.Alloc(); + return allocator.Alloc(); } template void operator delete(void* ptr, MEM_BlockAlloc& allocator) noexcept { - return allocator.Free(ptr); + return allocator.Free(ptr); } diff --git a/code/qcommon/mem_tempalloc.cpp b/code/qcommon/mem_tempalloc.cpp index 585598dc..f901e94b 100644 --- a/code/qcommon/mem_tempalloc.cpp +++ b/code/qcommon/mem_tempalloc.cpp @@ -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; } diff --git a/code/qcommon/mem_tempalloc.h b/code/qcommon/mem_tempalloc.h index 8c03825d..69606a6f 100644 --- a/code/qcommon/mem_tempalloc.h +++ b/code/qcommon/mem_tempalloc.h @@ -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; }; diff --git a/code/qcommon/script.cpp b/code/qcommon/script.cpp index 37bbb8c2..f73d0044 100644 --- a/code/qcommon/script.cpp +++ b/code/qcommon/script.cpp @@ -36,95 +36,89 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #include "g_local.h" -#define FILE_FS_FreeFile gi.FS_FreeFile -#define FILE_FS_ReadFile(a,b) gi.FS_ReadFile(a,b,true) -#define FILE_Malloc gi.Malloc -#define FILE_Free gi.Free -#define FILE_Error gi.Error +#define FILE_FS_FreeFile gi.FS_FreeFile +#define FILE_FS_ReadFile(a, b) gi.FS_ReadFile(a, b, true) +#define FILE_Malloc gi.Malloc +#define FILE_Free gi.Free +#define FILE_Error gi.Error #elif defined(CGAME_DLL) -#define FILE_FS_FreeFile cgi.FS_FreeFile -#define FILE_FS_ReadFile(a,b) cgi.FS_ReadFile(a,b,true) -#define FILE_Malloc cgi.Malloc -#define FILE_Free cgi.Free -#define FILE_Error cgi.Error +#define FILE_FS_FreeFile cgi.FS_FreeFile +#define FILE_FS_ReadFile(a, b) cgi.FS_ReadFile(a, b, true) +#define FILE_Malloc cgi.Malloc +#define FILE_Free cgi.Free +#define FILE_Error cgi.Error #else #include "qcommon.h" -#define FILE_FS_FreeFile FS_FreeFile -#define FILE_FS_ReadFile(a,b) FS_ReadFile(a,b) -#define FILE_Malloc Z_Malloc -#define FILE_Free Z_Free -#define FILE_Error Com_Error +#define FILE_FS_FreeFile FS_FreeFile +#define FILE_FS_ReadFile(a, b) FS_ReadFile(a, b) +#define FILE_Malloc Z_Malloc +#define FILE_Free Z_Free +#define FILE_Error Com_Error #endif typedef unsigned char byte; -CLASS_DECLARATION( Class, Script, NULL ) -{ - { NULL, NULL } +CLASS_DECLARATION(Class, Script, NULL){ + {NULL, NULL} }; -Script::~Script() -{ - Close(); -} +Script::~Script() { Close(); } Script::Script(const char* filename /*= 0*/) { - buffer = NULL; - script_p = NULL; - end_p = NULL; - line = 0; - length = 0; - releaseBuffer = false; - tokenready = false; - token[ 0 ] = 0; - - if ( filename != 0 ) - LoadFile( filename ); + buffer = NULL; + script_p = NULL; + end_p = NULL; + line = 0; + length = 0; + releaseBuffer = false; + tokenready = false; + token[0] = 0; + + if (filename != 0) { + LoadFile(filename); + } } Script::Script() { - buffer = NULL; - script_p = NULL; - end_p = NULL; - line = 0; - length = 0; - releaseBuffer = false; - tokenready = false; - token[ 0 ] = 0; + buffer = NULL; + script_p = NULL; + end_p = NULL; + line = 0; + length = 0; + releaseBuffer = false; + tokenready = false; + token[0] = 0; } -void Script::Close( void ) +void Script::Close(void) { - if ( releaseBuffer && buffer ) - { - FILE_Free( ( void * )buffer ); - } - - buffer = NULL; - script_p = NULL; - end_p = NULL; - line = 0; - releaseBuffer = false; - tokenready = false; - token[ 0 ] = 0; - - //Loop Through the macro container and delete (del33t -hehe) them all - for( int i = 1; i <= macrolist.NumObjects(); i++) - { - if (macrolist.ObjectAt( i ) ) - { - delete macrolist.ObjectAt( i ); - macrolist.ObjectAt( i ) = 0; - } - } + if (releaseBuffer && buffer) { + FILE_Free((void*)buffer); + } + + buffer = NULL; + script_p = NULL; + end_p = NULL; + line = 0; + releaseBuffer = false; + tokenready = false; + token[0] = 0; + + // Loop Through the macro container and delete (del33t -hehe) them all + for (int i = 1; i <= macrolist.NumObjects(); i++) { + if (macrolist.ObjectAt(i)) { + delete macrolist.ObjectAt(i); + macrolist.ObjectAt(i) = 0; + } + } } /* @@ -135,10 +129,7 @@ void Script::Close( void ) ============== */ -const char *Script::Filename( void ) -{ - return filename.c_str(); -} +const char* Script::Filename(void) { return filename.c_str(); } /* ============== @@ -148,10 +139,7 @@ const char *Script::Filename( void ) ============== */ -int Script::GetLineNumber( void ) -{ - return line; -} +int Script::GetLineNumber(void) { return line; } /* ============== @@ -161,12 +149,12 @@ int Script::GetLineNumber( void ) ============== */ -void Script::Reset( void ) +void Script::Reset(void) { - script_p = buffer; - line = 1; - tokenready = false; - hasError = false; + script_p = buffer; + line = 1; + tokenready = false; + hasError = false; } /* @@ -177,14 +165,14 @@ void Script::Reset( void ) ============== */ -void Script::MarkPosition( scriptmarker_t *mark ) +void Script::MarkPosition(scriptmarker_t* mark) { - assert( mark ); - - mark->tokenready = tokenready; - mark->offset = script_p - buffer; - mark->line = line; - strcpy( mark->token, token ); + assert(mark); + + mark->tokenready = tokenready; + mark->offset = script_p - buffer; + mark->line = line; + strcpy(mark->token, token); } /* @@ -195,20 +183,19 @@ void Script::MarkPosition( scriptmarker_t *mark ) ============== */ -void Script::RestorePosition( const scriptmarker_t *mark ) +void Script::RestorePosition(const scriptmarker_t* mark) { - assert( mark ); - - tokenready = mark->tokenready; - script_p = buffer + mark->offset; - line = mark->line; - strcpy( token, mark->token ); - - assert( script_p <= end_p ); - if ( script_p > end_p ) - { - script_p = end_p; - } + assert(mark); + + tokenready = mark->tokenready; + script_p = buffer + mark->offset; + line = mark->line; + strcpy(token, mark->token); + + assert(script_p <= end_p); + if (script_p > end_p) { + script_p = end_p; + } } /* @@ -219,22 +206,19 @@ void Script::RestorePosition( const scriptmarker_t *mark ) ============== */ -qboolean Script::SkipToEOL( void ) +qboolean Script::SkipToEOL(void) { - if ( script_p >= end_p ) - { - return true; - } - - while( *script_p != TOKENEOL ) - { - if ( script_p >= end_p ) - { - return true; - } - script_p++; - } - return false; + if (script_p >= end_p) { + return true; + } + + while (*script_p != TOKENEOL) { + if (script_p >= end_p) { + return true; + } + script_p++; + } + return false; } /* @@ -245,12 +229,13 @@ qboolean Script::SkipToEOL( void ) ============== */ -void Script::CheckOverflow( void ) +void Script::CheckOverflow(void) { - if ( script_p >= end_p ) - { - FILE_Error( ERR_DROP, "End of token file reached prematurely reading %s\n", filename.c_str() ); - } + if (script_p >= end_p) { + FILE_Error(ERR_DROP, + "End of token file reached prematurely reading %s\n", + filename.c_str()); + } } /* @@ -261,57 +246,50 @@ void Script::CheckOverflow( void ) ============== */ -void Script::SkipWhiteSpace( qboolean crossline ) +void Script::SkipWhiteSpace(qboolean crossline) { - // - // skip space - // - CheckOverflow(); - - while( *script_p <= TOKENSPACE ) - { - if ( *script_p++ == TOKENEOL ) - { - if ( !crossline ) - { - FILE_Error( ERR_DROP, "Line %i is incomplete in file %s\n", line, filename.c_str() ); - } - - line++; - } - CheckOverflow(); - } + // + // skip space + // + CheckOverflow(); + + while (*script_p <= TOKENSPACE) { + if (*script_p++ == TOKENEOL) { + if (!crossline) { + FILE_Error(ERR_DROP, "Line %i is incomplete in file %s\n", line, + filename.c_str()); + } + + line++; + } + CheckOverflow(); + } } -qboolean Script::AtComment( void ) +qboolean Script::AtComment(void) { - if ( script_p >= end_p ) - { - return false; - } - - if ( *script_p == TOKENCOMMENT ) - { - return true; - } - - if ( *script_p == TOKENCOMMENT2 ) - { - return true; - } - - // Two or more character comment specifiers - if ( ( script_p + 1 ) >= end_p ) - { - return false; - } - - if ( ( *script_p == '/' ) && ( *( script_p + 1 ) == '/' ) ) - { - return true; - } - - return false; + if (script_p >= end_p) { + return false; + } + + if (*script_p == TOKENCOMMENT) { + return true; + } + + if (*script_p == TOKENCOMMENT2) { + return true; + } + + // Two or more character comment specifiers + if ((script_p + 1) >= end_p) { + return false; + } + + if ((*script_p == '/') && (*(script_p + 1) == '/')) { + return true; + } + + return false; } /* @@ -322,17 +300,16 @@ qboolean Script::AtComment( void ) ============== */ -void Script::SkipNonToken( qboolean crossline ) +void Script::SkipNonToken(qboolean crossline) { - // - // skip space and comments - // - SkipWhiteSpace( crossline ); - while( AtComment() ) - { - SkipToEOL(); - SkipWhiteSpace( crossline ); - } + // + // skip space and comments + // + SkipWhiteSpace(crossline); + while (AtComment()) { + SkipToEOL(); + SkipWhiteSpace(crossline); + } } /* @@ -351,50 +328,40 @@ void Script::SkipNonToken( qboolean crossline ) ============== */ -qboolean Script::TokenAvailable( qboolean crossline ) +qboolean Script::TokenAvailable(qboolean crossline) { - if ( script_p >= end_p ) - { - return false; - } - - while ( 1 ) - { - while ( *script_p <= TOKENSPACE ) - { - if ( *script_p == TOKENEOL ) - { - if ( !crossline ) - { - return( false ); - } - line++; - } - - script_p++; - if ( script_p >= end_p ) - { - return false; - } - } - - if ( AtComment() ) - { - qboolean done; - - done = SkipToEOL(); - if ( done ) - { - return false; - } - } - else - { - break; - } - } - - return true; + if (script_p >= end_p) { + return false; + } + + while (1) { + while (*script_p <= TOKENSPACE) { + if (*script_p == TOKENEOL) { + if (!crossline) { + return (false); + } + line++; + } + + script_p++; + if (script_p >= end_p) { + return false; + } + } + + if (AtComment()) { + qboolean done; + + done = SkipToEOL(); + if (done) { + return false; + } + } else { + break; + } + } + + return true; } /* @@ -405,31 +372,27 @@ qboolean Script::TokenAvailable( qboolean crossline ) ============== */ -qboolean Script::CommentAvailable( qboolean crossline ) +qboolean Script::CommentAvailable(qboolean crossline) { - const char *searchptr; - - searchptr = script_p; - - if ( searchptr >= end_p ) - { - return false; - } - - while ( *searchptr <= TOKENSPACE ) - { - if ( ( *searchptr == TOKENEOL ) && ( !crossline ) ) - { - return false; - } - searchptr++; - if ( searchptr >= end_p ) - { - return false; - } - } - - return true; + const char* searchptr; + + searchptr = script_p; + + if (searchptr >= end_p) { + return false; + } + + while (*searchptr <= TOKENSPACE) { + if ((*searchptr == TOKENEOL) && (!crossline)) { + return false; + } + searchptr++; + if (searchptr >= end_p) { + return false; + } + } + + return true; } /* @@ -449,10 +412,7 @@ GetToken (false); ============== */ -void Script::UnGetToken( void ) -{ - tokenready = true; -} +void Script::UnGetToken(void) { tokenready = true; } /* ============== @@ -461,68 +421,68 @@ void Script::UnGetToken( void ) = ============== */ -qboolean Script::AtString( qboolean crossline ) +qboolean Script::AtString(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); - - return ( *script_p == '"' ); + // + // skip space + // + SkipNonToken(crossline); + + return (*script_p == '"'); } -qboolean Script::AtOpenParen( qboolean crossline ) +qboolean Script::AtOpenParen(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); - - return ( *script_p == '(' ); + // + // skip space + // + SkipNonToken(crossline); + + return (*script_p == '('); } -qboolean Script::AtCloseParen( qboolean crossline ) +qboolean Script::AtCloseParen(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); - - return ( *script_p == ')' ); + // + // skip space + // + SkipNonToken(crossline); + + return (*script_p == ')'); } -qboolean Script::AtComma( qboolean crossline ) +qboolean Script::AtComma(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); + // + // skip space + // + SkipNonToken(crossline); - return ( *script_p == ',' ); + return (*script_p == ','); } -qboolean Script::AtDot( qboolean crossline ) +qboolean Script::AtDot(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); + // + // skip space + // + SkipNonToken(crossline); - return ( *script_p == '.' ); + return (*script_p == '.'); } -qboolean Script::AtAssignment( qboolean crossline ) +qboolean Script::AtAssignment(qboolean crossline) { - // - // skip space - // - SkipNonToken( crossline ); + // + // skip space + // + SkipNonToken(crossline); - return ( *script_p == '=' ) || - ( ( *script_p == '+' ) && ( *( script_p + 1 ) == '=' ) ) || - ( ( *script_p == '-' ) && ( *( script_p + 1 ) == '=' ) ) || - ( ( *script_p == '*' ) && ( *( script_p + 1 ) == '=' ) ) || - ( ( *script_p == '/' ) && ( *( script_p + 1 ) == '=' ) ); + return (*script_p == '=') || + ((*script_p == '+') && (*(script_p + 1) == '=')) || + ((*script_p == '-') && (*(script_p + 1) == '=')) || + ((*script_p == '*') && (*(script_p + 1) == '=')) || + ((*script_p == '/') && (*(script_p + 1) == '=')); } /* @@ -533,45 +493,41 @@ qboolean Script::AtAssignment( qboolean crossline ) ============== */ -const char *Script::GetToken( qboolean crossline ) +const char* Script::GetToken(qboolean crossline) { - - str token_p = token; - qboolean is_Macro = false; - - // is a token already waiting? - if ( tokenready ) - { - tokenready = false; - return token; - } - - is_Macro = isMacro(); - - token_p = GrabNextToken(crossline); - - if ( is_Macro && ( token_p != "$include" ) ) - { - - //Check to see if we need to add any definitions - while ( ( token_p == "$define" ) || ( token_p == "$Define" ) ) - { - AddMacroDefinition(crossline); - is_Macro = isMacro(); - //if ( !is_Macro ) - // return ""; - token_p = GrabNextToken(crossline); - } - - //Check to see if we need return any defines strings - if( is_Macro && ( token_p != "$include" ) && ( token_p[token_p.length() - 1] == '$' ) ) - { - return GetMacroString(token_p); - } - - } - - return token; + + str token_p = token; + qboolean is_Macro = false; + + // is a token already waiting? + if (tokenready) { + tokenready = false; + return token; + } + + is_Macro = isMacro(); + + token_p = GrabNextToken(crossline); + + if (is_Macro && (token_p != "$include")) { + + // Check to see if we need to add any definitions + while ((token_p == "$define") || (token_p == "$Define")) { + AddMacroDefinition(crossline); + is_Macro = isMacro(); + // if ( !is_Macro ) + // return ""; + token_p = GrabNextToken(crossline); + } + + // Check to see if we need return any defines strings + if (is_Macro && (token_p != "$include") && + (token_p[token_p.length() - 1] == '$')) { + return GetMacroString(token_p); + } + } + + return token; } /* @@ -581,60 +537,64 @@ const char *Script::GetToken( qboolean crossline ) = ============== */ -const char *Script::GrabNextToken( qboolean crossline ) +const char* Script::GrabNextToken(qboolean crossline) { - char *token_p; - - // - // skip space - // - SkipNonToken( crossline ); - - // - // copy token - // - if ( *script_p == '"' ) - { - return GetString( crossline ); - } - - token_p = token; - while( ( *script_p > TOKENSPACE ) && !AtComment() ) - { - if ( ( *script_p == '\\' ) && ( script_p < ( end_p - 1 ) ) ) - { - script_p++; - switch( *script_p ) - { - case 'n' : *token_p++ = '\n'; break; - case 'r' : *token_p++ = '\n'; break; - case '\'' : *token_p++ = '\''; break; - case '\"' : *token_p++ = '\"'; break; - case '\\' : *token_p++ = '\\'; break; - default: *token_p++ = *script_p; break; - } - script_p++; - } - else - { - *token_p++ = *script_p++; - } - - if ( token_p == &token[ MAXTOKEN ] ) - { - FILE_Error( ERR_DROP, "Token too large on line %i in file %s\n", line, filename.c_str() ); - } - - if ( script_p == end_p ) - { - break; - } - } - - - *token_p = 0; - - return token; + char* token_p; + + // + // skip space + // + SkipNonToken(crossline); + + // + // copy token + // + if (*script_p == '"') { + return GetString(crossline); + } + + token_p = token; + while ((*script_p > TOKENSPACE) && !AtComment()) { + if ((*script_p == '\\') && (script_p < (end_p - 1))) { + script_p++; + switch (*script_p) { + case 'n': + *token_p++ = '\n'; + break; + case 'r': + *token_p++ = '\n'; + break; + case '\'': + *token_p++ = '\''; + break; + case '\"': + *token_p++ = '\"'; + break; + case '\\': + *token_p++ = '\\'; + break; + default: + *token_p++ = *script_p; + break; + } + script_p++; + } else { + *token_p++ = *script_p++; + } + + if (token_p == &token[MAXTOKEN]) { + FILE_Error(ERR_DROP, "Token too large on line %i in file %s\n", + line, filename.c_str()); + } + + if (script_p == end_p) { + break; + } + } + + *token_p = 0; + + return token; } /* @@ -644,29 +604,31 @@ const char *Script::GrabNextToken( qboolean crossline ) = ============== */ -void Script::AddMacroDefinition( qboolean crossline ) +void Script::AddMacroDefinition(qboolean crossline) { - macro *theMacro; - - //Create a new macro structure. This new macro will be deleted in the script close() - theMacro = new macro; - - //Grab the macro name - theMacro->macroName = "$"; - theMacro->macroName.append(GrabNextToken(crossline)); - theMacro->macroName.append( "$" ); //<-- Adding closing ($) to keep formatting consistant - - //Grab the macro string - str tmpstr; - tmpstr = GrabNextToken(crossline); - //Check to see if we need return any defines strings - if( ( tmpstr != "$include" ) && ( tmpstr[tmpstr.length() - 1] == '$' ) ) - theMacro->macroText = GetMacroString(tmpstr); - else - theMacro->macroText = tmpstr; - - macrolist.AddObject( theMacro ); - + macro* theMacro; + + // Create a new macro structure. This new macro will be deleted in the + // script close() + theMacro = new macro; + + // Grab the macro name + theMacro->macroName = "$"; + theMacro->macroName.append(GrabNextToken(crossline)); + theMacro->macroName.append( + "$"); //<-- Adding closing ($) to keep formatting consistant + + // Grab the macro string + str tmpstr; + tmpstr = GrabNextToken(crossline); + // Check to see if we need return any defines strings + if ((tmpstr != "$include") && (tmpstr[tmpstr.length() - 1] == '$')) { + theMacro->macroText = GetMacroString(tmpstr); + } else { + theMacro->macroText = tmpstr; + } + + macrolist.AddObject(theMacro); } /* @@ -676,37 +638,36 @@ void Script::AddMacroDefinition( qboolean crossline ) = ============== */ -const char *Script::GetMacroString( const char *theMacroName ) +const char* Script::GetMacroString(const char* theMacroName) { - - macro *theMacro =0; //Initialize this puppy - - for( int i = 1; i <= macrolist.NumObjects(); i++) - { - theMacro = macrolist.ObjectAt( i ); - - if(!theMacro->macroName.cmp(theMacro->macroName.c_str(), theMacroName)) - { - const char *text = theMacro->macroText.c_str(); - - // If our define value is another define... - if( text[0] == '$' ) - return EvaluateMacroString(text); - else - return text; - } - - } - - char tmpstr[255], *sptr = tmpstr; - strcpy(tmpstr, theMacroName); - tmpstr[strlen(tmpstr)-1] = 0; - sptr++; - - // We didn't find what we were looking for - FILE_Error( ERR_DROP, "No Macro Text found for %s in file %s\n", theMacroName, filename.c_str() ); - return 0; - + + macro* theMacro = 0; // Initialize this puppy + + for (int i = 1; i <= macrolist.NumObjects(); i++) { + theMacro = macrolist.ObjectAt(i); + + if (!theMacro->macroName.cmp(theMacro->macroName.c_str(), + theMacroName)) { + const char* text = theMacro->macroText.c_str(); + + // If our define value is another define... + if (text[0] == '$') { + return EvaluateMacroString(text); + } else { + return text; + } + } + } + + char tmpstr[255], *sptr = tmpstr; + strcpy(tmpstr, theMacroName); + tmpstr[strlen(tmpstr) - 1] = 0; + sptr++; + + // We didn't find what we were looking for + FILE_Error(ERR_DROP, "No Macro Text found for %s in file %s\n", + theMacroName, filename.c_str()); + return 0; } //================================================================ @@ -721,10 +682,7 @@ const char *Script::GetMacroString( const char *theMacroName ) // Returns: None // //================================================================ -void Script::AddMacro(const char *name, const char *value) -{ - -} +void Script::AddMacro(const char* name, const char* value) {} /* ============== @@ -733,46 +691,59 @@ void Script::AddMacro(const char *name, const char *value) = ============== */ -char *Script::EvaluateMacroString( const char *theMacroString ) +char* Script::EvaluateMacroString(const char* theMacroString) { - static char evalText[255]; - char buffer[255], *bufferptr = buffer, oper = '+', newoper = '+'; - bool haveoper = false; - int i; - float value = 0.0f, val = 0.0f; - memset(buffer, 0, 255); - - for ( i=0;i<=strlen(theMacroString);i++ ) - { - if ( theMacroString[i] == '+' ) { haveoper = true; newoper = '+'; } - if ( theMacroString[i] == '-' ) { haveoper = true; newoper = '-'; } - if ( theMacroString[i] == '*' ) { haveoper = true; newoper = '*'; } - if ( theMacroString[i] == '/' ) { haveoper = true; newoper = '/'; } - if ( theMacroString[i] == 0 ) haveoper = true; - - if ( haveoper ) - { - if ( buffer[0] == '$' ) - val = atof(GetMacroString(buffer)); - else - val = atof(buffer); - - value = EvaluateMacroMath(value, val, oper); - oper = newoper; - - // Reset everything - haveoper = false; - memset(buffer, 0, 255); - bufferptr = buffer; - continue; - } - - *bufferptr = theMacroString[i]; - bufferptr++; - } - - sprintf(evalText,"%f",value); - return evalText; + static char evalText[255]; + char buffer[255], *bufferptr = buffer, oper = '+', newoper = '+'; + bool haveoper = false; + int i; + float value = 0.0f, val = 0.0f; + memset(buffer, 0, 255); + + for (i = 0; i <= strlen(theMacroString); i++) { + if (theMacroString[i] == '+') { + haveoper = true; + newoper = '+'; + } + if (theMacroString[i] == '-') { + haveoper = true; + newoper = '-'; + } + if (theMacroString[i] == '*') { + haveoper = true; + newoper = '*'; + } + if (theMacroString[i] == '/') { + haveoper = true; + newoper = '/'; + } + if (theMacroString[i] == 0) { + haveoper = true; + } + + if (haveoper) { + if (buffer[0] == '$') { + val = atof(GetMacroString(buffer)); + } else { + val = atof(buffer); + } + + value = EvaluateMacroMath(value, val, oper); + oper = newoper; + + // Reset everything + haveoper = false; + memset(buffer, 0, 255); + bufferptr = buffer; + continue; + } + + *bufferptr = theMacroString[i]; + bufferptr++; + } + + sprintf(evalText, "%f", value); + return evalText; } /* @@ -784,15 +755,22 @@ char *Script::EvaluateMacroString( const char *theMacroString ) */ float Script::EvaluateMacroMath(float value, float newval, char oper) { - switch ( oper ) - { - case '+' : value += newval; break; - case '-' : value -= newval; break; - case '*' : value *= newval; break; - case '/' : value /= newval; break; - } + switch (oper) { + case '+': + value += newval; + break; + case '-': + value -= newval; + break; + case '*': + value *= newval; + break; + case '/': + value /= newval; + break; + } - return value; + return value; } /* @@ -802,18 +780,18 @@ float Script::EvaluateMacroMath(float value, float newval, char oper) = ============== */ -qboolean Script::isMacro( void ) +qboolean Script::isMacro(void) { - if ( !TokenAvailable( true ) ) - return false; - - SkipNonToken( true ); - if ( *script_p == TOKENSPECIAL ) - { - return true; - } - - return false; + if (!TokenAvailable(true)) { + return false; + } + + SkipNonToken(true); + if (*script_p == TOKENSPECIAL) { + return true; + } + + return false; } /* @@ -824,40 +802,37 @@ qboolean Script::isMacro( void ) ============== */ -const char *Script::GetLine( qboolean crossline ) +const char* Script::GetLine(qboolean crossline) { - const char *start; - int size; - - // is a token already waiting? - if ( tokenready ) - { - tokenready = false; - return token; - } - - // - // skip space - // - SkipNonToken( crossline ); - - // - // copy token - // - start = script_p; - SkipToEOL(); - size = script_p - start; - if ( size < ( MAXTOKEN - 1 ) ) - { - memcpy( token, start, size ); - token[ size ] = '\0'; - } - else - { - FILE_Error( ERR_DROP, "Token too large on line %i in file %s\n", line, filename.c_str() ); - } - - return token; + const char* start; + int size; + + // is a token already waiting? + if (tokenready) { + tokenready = false; + return token; + } + + // + // skip space + // + SkipNonToken(crossline); + + // + // copy token + // + start = script_p; + SkipToEOL(); + size = script_p - start; + if (size < (MAXTOKEN - 1)) { + memcpy(token, start, size); + token[size] = '\0'; + } else { + FILE_Error(ERR_DROP, "Token too large on line %i in file %s\n", line, + filename.c_str()); + } + + return token; } /* @@ -868,33 +843,31 @@ const char *Script::GetLine( qboolean crossline ) ============== */ -const char *Script::GetRaw( void ) +const char* Script::GetRaw(void) { - const char *start; - int size; - - // - // skip white space - // - SkipWhiteSpace( true ); - - // - // copy token - // - start = script_p; - SkipToEOL(); - size = script_p - start; - if ( size < ( MAXTOKEN - 1 ) ) - { - memset( token, 0, sizeof( token ) ); - memcpy( token, start, size ); - } - else - { - FILE_Error( ERR_DROP, "Token too large on line %i in file %s\n", line, filename.c_str() ); - } - - return token; + const char* start; + int size; + + // + // skip white space + // + SkipWhiteSpace(true); + + // + // copy token + // + start = script_p; + SkipToEOL(); + size = script_p - start; + if (size < (MAXTOKEN - 1)) { + memset(token, 0, sizeof(token)); + memcpy(token, start, size); + } else { + FILE_Error(ERR_DROP, "Token too large on line %i in file %s\n", line, + filename.c_str()); + } + + return token; } /* @@ -905,76 +878,86 @@ const char *Script::GetRaw( void ) ============== */ -const char *Script::GetString( qboolean crossline ) +const char* Script::GetString(qboolean crossline) { - int startline; - char *token_p; - - // is a token already waiting? - if ( tokenready ) - { - tokenready = false; - return token; - } - - // - // skip space - // - SkipNonToken( crossline ); - - if ( *script_p != '"' ) - { - FILE_Error( ERR_DROP, "Expecting string on line %i in file %s\n", line, filename.c_str() ); - } - - script_p++; - - startline = line; - token_p = token; - while( *script_p != '"' ) - { - if ( *script_p == TOKENEOL ) - { - FILE_Error( ERR_DROP, "Line %i is incomplete while reading string in file %s\n", line, filename.c_str() ); - } - - if ( ( *script_p == '\\' ) && ( script_p < ( end_p - 1 ) ) ) - { - script_p++; - switch( *script_p ) - { - case 'n' : *token_p++ = '\n'; break; - case 'r' : *token_p++ = '\n'; break; - case '\'' : *token_p++ = '\''; break; - case '\"' : *token_p++ = '\"'; break; - case '\\' : *token_p++ = '\\'; break; - default: *token_p++ = *script_p; break; - } - script_p++; - } - else - { - *token_p++ = *script_p++; - } - - if ( script_p >= end_p ) - { - FILE_Error( ERR_DROP, "End of token file reached prematurely while reading string on\n" - "line %d in file %s\n", startline, filename.c_str() ); - } - - if ( token_p == &token[ MAXTOKEN ] ) - { - FILE_Error( ERR_DROP, "String too large on line %i in file %s\n", line, filename.c_str() ); - } - } - - *token_p = 0; - - // skip last quote - script_p++; - - return token; + int startline; + char* token_p; + + // is a token already waiting? + if (tokenready) { + tokenready = false; + return token; + } + + // + // skip space + // + SkipNonToken(crossline); + + if (*script_p != '"') { + FILE_Error(ERR_DROP, "Expecting string on line %i in file %s\n", line, + filename.c_str()); + } + + script_p++; + + startline = line; + token_p = token; + while (*script_p != '"') { + if (*script_p == TOKENEOL) { + FILE_Error( + ERR_DROP, + "Line %i is incomplete while reading string in file %s\n", line, + filename.c_str()); + } + + if ((*script_p == '\\') && (script_p < (end_p - 1))) { + script_p++; + switch (*script_p) { + case 'n': + *token_p++ = '\n'; + break; + case 'r': + *token_p++ = '\n'; + break; + case '\'': + *token_p++ = '\''; + break; + case '\"': + *token_p++ = '\"'; + break; + case '\\': + *token_p++ = '\\'; + break; + default: + *token_p++ = *script_p; + break; + } + script_p++; + } else { + *token_p++ = *script_p++; + } + + if (script_p >= end_p) { + FILE_Error(ERR_DROP, + "End of token file reached prematurely while reading " + "string on\n" + "line %d in file %s\n", + startline, filename.c_str()); + } + + if (token_p == &token[MAXTOKEN]) { + FILE_Error(ERR_DROP, "String too large on line %i in file %s\n", + line, filename.c_str()); + } + } + + *token_p = 0; + + // skip last quote + script_p++; + + return token; } /* @@ -985,19 +968,16 @@ const char *Script::GetString( qboolean crossline ) ============== */ -qboolean Script::GetSpecific( const char *string ) +qboolean Script::GetSpecific(const char* string) { - do - { - if ( !TokenAvailable( true ) ) - { - return false; - } - GetToken( true ); - } - while( strcmp( token, string ) ); - - return true; + do { + if (!TokenAvailable(true)) { + return false; + } + GetToken(true); + } while (strcmp(token, string)); + + return true; } //=============================================================== @@ -1008,21 +988,22 @@ qboolean Script::GetSpecific( const char *string ) // stream. If the next token is either "true" // or "1", then it returns true. Otherwise, it // returns false. -// +// // Parameters: qboolean -- determines if token parsing can cross newlines // // Returns: qboolean -- true if next token was "true" (or "1") -// +// //=============================================================== -qboolean Script::GetBoolean( qboolean crossline ) +qboolean Script::GetBoolean(qboolean crossline) { - GetToken( crossline ); - if ( Q_stricmp( token, "true" ) == 0 ) - return true; - else if( Q_stricmp( token, "1" ) == 0 ) - return true; + GetToken(crossline); + if (Q_stricmp(token, "true") == 0) { + return true; + } else if (Q_stricmp(token, "1") == 0) { + return true; + } - return false; + return false; } /* @@ -1033,10 +1014,10 @@ qboolean Script::GetBoolean( qboolean crossline ) ============== */ -int Script::GetInteger( qboolean crossline ) +int Script::GetInteger(qboolean crossline) { - GetToken( crossline ); - return atoi( token ); + GetToken(crossline); + return atoi(token); } /* @@ -1047,10 +1028,10 @@ int Script::GetInteger( qboolean crossline ) ============== */ -double Script::GetDouble( qboolean crossline ) +double Script::GetDouble(qboolean crossline) { - GetToken( crossline ); - return atof( token ); + GetToken(crossline); + return atof(token); } /* @@ -1061,9 +1042,9 @@ double Script::GetDouble( qboolean crossline ) ============== */ -float Script::GetFloat( qboolean crossline ) +float Script::GetFloat(qboolean crossline) { - return ( float )GetDouble( crossline ); + return (float)GetDouble(crossline); } /* @@ -1074,12 +1055,12 @@ float Script::GetFloat( qboolean crossline ) ============== */ -Vector Script::GetVector( qboolean crossline ) +Vector Script::GetVector(qboolean crossline) { - float x = GetFloat( crossline ); - float y = GetFloat( crossline ); - float z = GetFloat( crossline ); - return Vector( x, y, z ); + float x = GetFloat(crossline); + float y = GetFloat(crossline); + float z = GetFloat(crossline); + return Vector(x, y, z); } /* @@ -1089,34 +1070,33 @@ Vector Script::GetVector( qboolean crossline ) = =================== */ -int Script::LinesInFile( void ) +int Script::LinesInFile(void) { - qboolean temp_tokenready; - const char *temp_script_p; - int temp_line; - char temp_token[ MAXTOKEN ]; - int numentries; - - temp_tokenready = tokenready; - temp_script_p = script_p; - temp_line = line; - strcpy( temp_token, token ); - - numentries = 0; - - Reset(); - while( TokenAvailable( true ) ) - { - GetLine( true ); - numentries++; - } - - tokenready = temp_tokenready; - script_p = temp_script_p; - line = temp_line; - strcpy( token, temp_token ); - - return numentries; + qboolean temp_tokenready; + const char* temp_script_p; + int temp_line; + char temp_token[MAXTOKEN]; + int numentries; + + temp_tokenready = tokenready; + temp_script_p = script_p; + temp_line = line; + strcpy(temp_token, token); + + numentries = 0; + + Reset(); + while (TokenAvailable(true)) { + GetLine(true); + numentries++; + } + + tokenready = temp_tokenready; + script_p = temp_script_p; + line = temp_line; + strcpy(token, temp_token); + + return numentries; } /* @@ -1127,15 +1107,15 @@ int Script::LinesInFile( void ) ============== */ -void Script::Parse( const char *data, size_t length, const char *name ) +void Script::Parse(const char* data, size_t length, const char* name) { - Close(); - - buffer = data; - Reset(); - this->length = length; - end_p = script_p + length; - filename = name; + Close(); + + buffer = data; + Reset(); + this->length = length; + end_p = script_p + length; + filename = name; } /* @@ -1146,37 +1126,36 @@ void Script::Parse( const char *data, size_t length, const char *name ) ============== */ -void Script::LoadFile( const char *name ) +void Script::LoadFile(const char* name) { - int length; - byte *buffer; - byte *tempbuf; - const char *const_buffer; - - Close(); - - length = FILE_FS_ReadFile( name, ( void ** )&tempbuf ); + int length; + byte* buffer; + byte* tempbuf; + const char* const_buffer; - hasError = false; + Close(); - if ( length < 0 ) - { - hasError = true; - return; - } + length = FILE_FS_ReadFile(name, (void**)&tempbuf); - // create our own space - buffer = ( byte * )FILE_Malloc( length + 1 ); - // copy the file over to our space - memcpy( buffer, tempbuf, length ); - buffer[ length ] = 0; - // free the file - FILE_FS_FreeFile( tempbuf ); - - const_buffer = ( char * )buffer; - - Parse( const_buffer, length, name ); - releaseBuffer = true; + hasError = false; + + if (length < 0) { + hasError = true; + return; + } + + // create our own space + buffer = (byte*)FILE_Malloc(length + 1); + // copy the file over to our space + memcpy(buffer, tempbuf, length); + buffer[length] = 0; + // free the file + FILE_FS_FreeFile(tempbuf); + + const_buffer = (char*)buffer; + + Parse(const_buffer, length, name); + releaseBuffer = true; } /* @@ -1187,31 +1166,22 @@ void Script::LoadFile( const char *name ) ============== */ -void Script::LoadFile( const char *name, int length, const char *buf ) +void Script::LoadFile(const char* name, int length, const char* buf) { - Close(); + Close(); - // create our own space - this->buffer = ( const char * )FILE_Malloc( length ); - this->length = length; - // copy the file over to our space - memcpy( ( void * )this->buffer, buf, length ); + // create our own space + this->buffer = (const char*)FILE_Malloc(length); + this->length = length; + // copy the file over to our space + memcpy((void*)this->buffer, buf, length); - Parse( buffer, this->length, name ); - releaseBuffer = true; + Parse(buffer, this->length, name); + releaseBuffer = true; } -qboolean Script::isValid() -{ - return !hasError; -} +qboolean Script::isValid() { return !hasError; } -qboolean Script::EndOfFile( void ) -{ - return script_p >= end_p; -} +qboolean Script::EndOfFile(void) { return script_p >= end_p; } -const char *Script::Token( void ) -{ - return token; -} +const char* Script::Token(void) { return token; } diff --git a/code/qcommon/script.h b/code/qcommon/script.h index 62d29cb8..25b352c4 100644 --- a/code/qcommon/script.h +++ b/code/qcommon/script.h @@ -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 macrolist; + str filename; + const char* script_p; + const char* end_p; + Container 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 *GetMacroList() { return ¯olist; } - void AddMacro(const char *name, const char *value); - }; + Container* GetMacroList() { return ¯olist; } + 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 macrolist; + // const char *end_p; + // Container macrolist; - arc.ArchiveInteger( &line ); - arc.ArchiveRaw( &token, sizeof( token ) ); + arc.ArchiveInteger(&line); + arc.ArchiveRaw(&token, sizeof(token)); - //qboolean releaseBuffer; - } + // qboolean releaseBuffer; +} #endif #endif