mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-12 08:11:10 +02:00
Justin Marshall
2623 lines
70 KiB
C++
2623 lines
70 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
IceTech GPL Source Code
|
|
Copyright (C) 2026 Justin Marshall
|
|
|
|
This file is part of the IceTech GPL Source Code (?IceTech Source Code?).
|
|
|
|
IceTech Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
IceTech Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with IceTech Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the IceTech Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the IceTech Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing Justin Marshall, justinmarshall20@gmail.com
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
/*
|
|
|
|
GUIs and script remain separately parsed
|
|
|
|
Following a parse, all referenced media (and other decls) will have been touched.
|
|
|
|
sinTable and cosTable are required for the rotate material keyword to function
|
|
|
|
A new FindType on a purged decl will cause it to be reloaded, but a stale pointer to a purged
|
|
decl will look like a defaulted decl.
|
|
|
|
Moving a decl from one file to another will not be handled correctly by a reload, the material
|
|
will be defaulted.
|
|
|
|
NULL or empty decl names will always return NULL
|
|
Should probably make a default decl for this
|
|
|
|
Decls are initially created without a textSource
|
|
A parse without textSource set should always just call MakeDefault()
|
|
A parse that has an error should internally call MakeDefault()
|
|
A purge does nothing to a defaulted decl
|
|
|
|
Should we have a "purged" media state separate from the "defaulted" media state?
|
|
|
|
reloading over a decl name that was defaulted
|
|
|
|
reloading over a decl name that was valid
|
|
|
|
missing reload over a previously explicit definition
|
|
|
|
*/
|
|
|
|
#define USE_COMPRESSED_DECLS
|
|
//#define GET_HUFFMAN_FREQUENCIES
|
|
|
|
class idDeclType {
|
|
public:
|
|
idStr typeName;
|
|
declType_t type;
|
|
idDecl* (*allocator)(void);
|
|
};
|
|
|
|
class idDeclFolder {
|
|
public:
|
|
idStr folder;
|
|
idStr extension;
|
|
declType_t defaultType;
|
|
};
|
|
|
|
#ifdef QUAKE4
|
|
// jmarshall: Quake 4 guide/template support
|
|
struct rvGuideTemplate {
|
|
idStr name;
|
|
idList<idStr> parms;
|
|
idStr body;
|
|
bool inlineGuide;
|
|
};
|
|
#endif
|
|
|
|
class idDeclFile;
|
|
|
|
class idDeclLocal : public idDeclBase {
|
|
friend class idDeclFile;
|
|
friend class idDeclManagerLocal;
|
|
|
|
public:
|
|
idDeclLocal();
|
|
virtual ~idDeclLocal() {};
|
|
virtual const char* GetName(void) const;
|
|
virtual declType_t GetType(void) const;
|
|
virtual declState_t GetState(void) const;
|
|
virtual bool IsImplicit(void) const;
|
|
virtual bool IsValid(void) const;
|
|
virtual void Invalidate(void);
|
|
virtual void Reload(void);
|
|
virtual void EnsureNotPurged(void);
|
|
virtual int Index(void) const;
|
|
virtual int GetLineNum(void) const;
|
|
virtual const char* GetFileName(void) const;
|
|
virtual size_t Size(void) const;
|
|
virtual void GetText(char* text) const;
|
|
virtual int GetTextLength(void) const;
|
|
virtual void SetText(const char* text);
|
|
virtual bool ReplaceSourceFileText(void);
|
|
virtual bool SourceFileChanged(void) const;
|
|
virtual void MakeDefault(void);
|
|
virtual bool EverReferenced(void) const;
|
|
|
|
protected:
|
|
virtual bool SetDefaultText(void);
|
|
virtual const char* DefaultDefinition(void) const;
|
|
virtual bool Parse(const char* text, const int textLength);
|
|
virtual void FreeData(void);
|
|
virtual void List(void) const;
|
|
virtual void Print(void) const;
|
|
|
|
protected:
|
|
void AllocateSelf(void);
|
|
|
|
// Parses the decl definition.
|
|
// After calling parse, a decl will be guaranteed usable.
|
|
void ParseLocal(void);
|
|
|
|
// Does a MakeDefualt, but flags the decl so that it
|
|
// will Parse() the next time the decl is found.
|
|
void Purge(void);
|
|
|
|
// Set textSource possible with compression.
|
|
void SetTextLocal(const char* text, const int length);
|
|
|
|
private:
|
|
idDecl* self;
|
|
|
|
idStr name; // name of the decl
|
|
char* textSource; // decl text definition
|
|
int textLength; // length of textSource
|
|
int compressedLength; // compressed length
|
|
idDeclFile* sourceFile; // source file in which the decl was defined
|
|
int sourceTextOffset; // offset in source file to decl text
|
|
int sourceTextLength; // length of decl text in source file
|
|
int sourceLine; // this is where the actual declaration token starts
|
|
int checksum; // checksum of the decl text
|
|
declType_t type; // decl type
|
|
declState_t declState; // decl state
|
|
int index; // index in the per-type list
|
|
|
|
bool parsedOutsideLevelLoad; // these decls will never be purged
|
|
bool everReferenced; // set to true if the decl was ever used
|
|
bool referencedThisLevel; // set to true when the decl is used for the current level
|
|
bool redefinedInReload; // used during file reloading to make sure a decl that has
|
|
// its source removed will be defaulted
|
|
idDeclLocal* nextInFile; // next decl in the decl file
|
|
};
|
|
|
|
class idDeclFile {
|
|
public:
|
|
idDeclFile();
|
|
idDeclFile(const char* fileName, declType_t defaultType);
|
|
|
|
void Reload(bool force);
|
|
int LoadAndParse();
|
|
|
|
public:
|
|
idStr fileName;
|
|
declType_t defaultType;
|
|
|
|
ID_TIME_T timestamp;
|
|
int checksum;
|
|
int fileSize;
|
|
int numLines;
|
|
|
|
idDeclLocal* decls;
|
|
};
|
|
|
|
class idDeclManagerLocal : public idDeclManager {
|
|
friend class idDeclLocal;
|
|
|
|
public:
|
|
virtual void Init(void);
|
|
virtual void Shutdown(void);
|
|
virtual void Reload(bool force);
|
|
|
|
#ifdef QUAKE4
|
|
// Quake 4 guide/template support
|
|
virtual void ParseGuides(void);
|
|
virtual void ShutdownGuides(void);
|
|
virtual bool EvaluateGuide(idStr& name, idLexer* src, idStr& definition);
|
|
virtual bool EvaluateInlineGuide(idStr& name, idStr& definition);
|
|
#endif
|
|
|
|
virtual void BeginLevelLoad();
|
|
virtual void EndLevelLoad();
|
|
virtual void RegisterDeclType(const char* typeName, declType_t type, idDecl* (*allocator)(void));
|
|
virtual void RegisterDeclFolder(const char* folder, const char* extension, declType_t defaultType);
|
|
void RegisterDeclSubFolder(const char* folder, const char* extension, idList<idStr>& fileList);
|
|
virtual int GetChecksum(void) const;
|
|
virtual int GetNumDeclTypes(void) const;
|
|
virtual int GetNumDecls(declType_t type);
|
|
virtual const char* GetDeclNameFromType(declType_t type) const;
|
|
virtual declType_t GetDeclTypeFromName(const char* typeName) const;
|
|
virtual const idDecl* FindType(declType_t type, const char* name, bool makeDefault = true);
|
|
virtual const idDecl* DeclByIndex(declType_t type, int index, bool forceParse = true);
|
|
|
|
virtual const idDecl* FindDeclWithoutParsing(declType_t type, const char* name, bool makeDefault = true);
|
|
virtual void ReloadFile(const char* filename, bool force);
|
|
|
|
virtual void ListType(const idCmdArgs& args, declType_t type);
|
|
virtual void PrintType(const idCmdArgs& args, declType_t type);
|
|
|
|
virtual idDecl* CreateNewDecl(declType_t type, const char* name, const char* fileName);
|
|
|
|
//BSM Added for the material editors rename capabilities
|
|
virtual bool RenameDecl(declType_t type, const char* oldName, const char* newName);
|
|
|
|
virtual void MediaPrint(const char* fmt, ...) id_attribute((format(printf, 2, 3)));
|
|
virtual void WritePrecacheCommands(idFile* f);
|
|
|
|
virtual const idMaterial* FindMaterial(const char* name, bool makeDefault = true);
|
|
virtual const idDeclSkin* FindSkin(const char* name, bool makeDefault = true);
|
|
virtual const idSoundShader* FindSound(const char* name, bool makeDefault = true);
|
|
|
|
virtual const idMaterial* MaterialByIndex(int index, bool forceParse = true);
|
|
virtual const idDeclSkin* SkinByIndex(int index, bool forceParse = true);
|
|
virtual const idSoundShader* SoundByIndex(int index, bool forceParse = true);
|
|
|
|
virtual const class idDeclTable* FindTable(const char* name, bool makeDefault = true);
|
|
|
|
#ifdef QUAKE4
|
|
virtual const class rvDeclMatType* FindMaterialType(const char* name, bool makeDefault = true);
|
|
virtual const class rvDeclLipSync* FindLipSync(const char* name, bool makeDefault = true);
|
|
virtual const class rvDeclPlayback* FindPlayback(const char* name, bool makeDefault = true);
|
|
virtual const class rvDeclEffect* FindEffect(const char* name, bool makeDefault = true);
|
|
|
|
virtual const class rvDeclMatType* MaterialTypeByIndex(int index, bool forceParse = true);
|
|
virtual const class rvDeclLipSync* LipSyncByIndex(int index, bool forceParse = true);
|
|
virtual const class rvDeclPlayback* PlaybackByIndex(int index, bool forceParse = true);
|
|
virtual const class rvDeclEffect* EffectByIndex(int index, bool forceParse = true);
|
|
#endif
|
|
public:
|
|
static void MakeNameCanonical(const char* name, char* result, int maxLength);
|
|
idDeclLocal* FindTypeWithoutParsing(declType_t type, const char* name, bool makeDefault = true);
|
|
|
|
idDeclType* GetDeclType(int type) const { return declTypes[type]; }
|
|
const idDeclFile* GetImplicitDeclFile(void) const { return &implicitDecls; }
|
|
|
|
#ifdef QUAKE4
|
|
idList<rvGuideTemplate> guides;
|
|
#endif
|
|
|
|
private:
|
|
idList<idDeclType*> declTypes;
|
|
idList<idDeclFolder*> declFolders;
|
|
|
|
idList<idDeclFile*> loadedFiles;
|
|
idHashIndex hashTables[DECL_MAX_TYPES];
|
|
idList<idDeclLocal*> linearLists[DECL_MAX_TYPES];
|
|
idDeclFile implicitDecls; // this holds all the decls that were created because explicit
|
|
// text definitions were not found. Decls that became default
|
|
// because of a parse error are not in this list.
|
|
int checksum; // checksum of all loaded decl text
|
|
int indent; // for MediaPrint
|
|
bool insideLevelLoad;
|
|
|
|
static idCVar decl_show;
|
|
|
|
private:
|
|
static void ListDecls_f(const idCmdArgs& args);
|
|
static void ReloadDecls_f(const idCmdArgs& args);
|
|
static void TouchDecl_f(const idCmdArgs& args);
|
|
};
|
|
|
|
idCVar idDeclManagerLocal::decl_show("decl_show", "0", CVAR_SYSTEM, "set to 1 to print parses, 2 to also print references", 0, 2, idCmdSystem::ArgCompletion_Integer<0, 2>);
|
|
|
|
idDeclManagerLocal declManagerLocal;
|
|
idDeclManager* declManager = &declManagerLocal;
|
|
|
|
/*
|
|
====================================================================================
|
|
|
|
decl text huffman compression
|
|
|
|
====================================================================================
|
|
*/
|
|
|
|
const int MAX_HUFFMAN_SYMBOLS = 256;
|
|
|
|
typedef struct huffmanNode_s {
|
|
int symbol;
|
|
int frequency;
|
|
struct huffmanNode_s* next;
|
|
struct huffmanNode_s* children[2];
|
|
} huffmanNode_t;
|
|
|
|
typedef struct huffmanCode_s {
|
|
unsigned long bits[8];
|
|
int numBits;
|
|
} huffmanCode_t;
|
|
|
|
// compression ratio = 64%
|
|
static int huffmanFrequencies[] = {
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00078fb6, 0x000352a7, 0x00000002, 0x00000001, 0x0002795e, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00049600, 0x000000dd, 0x00018732, 0x0000005a, 0x00000007, 0x00000092, 0x0000000a, 0x00000919,
|
|
0x00002dcf, 0x00002dda, 0x00004dfc, 0x0000039a, 0x000058be, 0x00002d13, 0x00014d8c, 0x00023c60,
|
|
0x0002ddb0, 0x0000d1fc, 0x000078c4, 0x00003ec7, 0x00003113, 0x00006b59, 0x00002499, 0x0000184a,
|
|
0x0000250b, 0x00004e38, 0x000001ca, 0x00000011, 0x00000020, 0x000023da, 0x00000012, 0x00000091,
|
|
0x0000000b, 0x00000b14, 0x0000035d, 0x0000137e, 0x000020c9, 0x00000e11, 0x000004b4, 0x00000737,
|
|
0x000006b8, 0x00001110, 0x000006b3, 0x000000fe, 0x00000f02, 0x00000d73, 0x000005f6, 0x00000be4,
|
|
0x00000d86, 0x0000014d, 0x00000d89, 0x0000129b, 0x00000db3, 0x0000015a, 0x00000167, 0x00000375,
|
|
0x00000028, 0x00000112, 0x00000018, 0x00000678, 0x0000081a, 0x00000677, 0x00000003, 0x00018112,
|
|
0x00000001, 0x000441ee, 0x000124b0, 0x0001fa3f, 0x00026125, 0x0005a411, 0x0000e50f, 0x00011820,
|
|
0x00010f13, 0x0002e723, 0x00003518, 0x00005738, 0x0002cc26, 0x0002a9b7, 0x0002db81, 0x0003b5fa,
|
|
0x000185d2, 0x00001299, 0x00030773, 0x0003920d, 0x000411cd, 0x00018751, 0x00005fbd, 0x000099b0,
|
|
0x00009242, 0x00007cf2, 0x00002809, 0x00005a1d, 0x00000001, 0x00005a1d, 0x00000001, 0x00000001,
|
|
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
|
|
};
|
|
|
|
static huffmanCode_t huffmanCodes[MAX_HUFFMAN_SYMBOLS];
|
|
static huffmanNode_t* huffmanTree = NULL;
|
|
static int totalUncompressedLength = 0;
|
|
static int totalCompressedLength = 0;
|
|
static int maxHuffmanBits = 0;
|
|
|
|
|
|
/*
|
|
================
|
|
ClearHuffmanFrequencies
|
|
================
|
|
*/
|
|
void ClearHuffmanFrequencies(void) {
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_HUFFMAN_SYMBOLS; i++) {
|
|
huffmanFrequencies[i] = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
InsertHuffmanNode
|
|
================
|
|
*/
|
|
huffmanNode_t* InsertHuffmanNode(huffmanNode_t* firstNode, huffmanNode_t* node) {
|
|
huffmanNode_t* n, * lastNode;
|
|
|
|
lastNode = NULL;
|
|
for (n = firstNode; n; n = n->next) {
|
|
if (node->frequency <= n->frequency) {
|
|
break;
|
|
}
|
|
lastNode = n;
|
|
}
|
|
if (lastNode) {
|
|
node->next = lastNode->next;
|
|
lastNode->next = node;
|
|
}
|
|
else {
|
|
node->next = firstNode;
|
|
firstNode = node;
|
|
}
|
|
return firstNode;
|
|
}
|
|
|
|
/*
|
|
================
|
|
BuildHuffmanCode_r
|
|
================
|
|
*/
|
|
void BuildHuffmanCode_r(huffmanNode_t* node, huffmanCode_t code, huffmanCode_t codes[MAX_HUFFMAN_SYMBOLS]) {
|
|
if (node->symbol == -1) {
|
|
huffmanCode_t newCode = code;
|
|
assert(code.numBits < sizeof(codes[0].bits) * 8);
|
|
newCode.numBits++;
|
|
if (code.numBits > maxHuffmanBits) {
|
|
maxHuffmanBits = newCode.numBits;
|
|
}
|
|
BuildHuffmanCode_r(node->children[0], newCode, codes);
|
|
newCode.bits[code.numBits >> 5] |= 1 << (code.numBits & 31);
|
|
BuildHuffmanCode_r(node->children[1], newCode, codes);
|
|
}
|
|
else {
|
|
assert(code.numBits <= sizeof(codes[0].bits) * 8);
|
|
codes[node->symbol] = code;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
FreeHuffmanTree_r
|
|
================
|
|
*/
|
|
void FreeHuffmanTree_r(huffmanNode_t* node) {
|
|
if (node->symbol == -1) {
|
|
FreeHuffmanTree_r(node->children[0]);
|
|
FreeHuffmanTree_r(node->children[1]);
|
|
}
|
|
delete node;
|
|
}
|
|
|
|
/*
|
|
================
|
|
HuffmanHeight_r
|
|
================
|
|
*/
|
|
int HuffmanHeight_r(huffmanNode_t* node) {
|
|
if (node == NULL) {
|
|
return -1;
|
|
}
|
|
int left = HuffmanHeight_r(node->children[0]);
|
|
int right = HuffmanHeight_r(node->children[1]);
|
|
if (left > right) {
|
|
return left + 1;
|
|
}
|
|
return right + 1;
|
|
}
|
|
|
|
/*
|
|
================
|
|
SetupHuffman
|
|
================
|
|
*/
|
|
void SetupHuffman(void) {
|
|
int i, height;
|
|
huffmanNode_t* firstNode, * node;
|
|
huffmanCode_t code;
|
|
|
|
firstNode = NULL;
|
|
for (i = 0; i < MAX_HUFFMAN_SYMBOLS; i++) {
|
|
node = new huffmanNode_t;
|
|
node->symbol = i;
|
|
node->frequency = huffmanFrequencies[i];
|
|
node->next = NULL;
|
|
node->children[0] = NULL;
|
|
node->children[1] = NULL;
|
|
firstNode = InsertHuffmanNode(firstNode, node);
|
|
}
|
|
|
|
for (i = 1; i < MAX_HUFFMAN_SYMBOLS; i++) {
|
|
node = new huffmanNode_t;
|
|
node->symbol = -1;
|
|
node->frequency = firstNode->frequency + firstNode->next->frequency;
|
|
node->next = NULL;
|
|
node->children[0] = firstNode;
|
|
node->children[1] = firstNode->next;
|
|
firstNode = InsertHuffmanNode(firstNode->next->next, node);
|
|
}
|
|
|
|
maxHuffmanBits = 0;
|
|
memset(&code, 0, sizeof(code));
|
|
BuildHuffmanCode_r(firstNode, code, huffmanCodes);
|
|
|
|
huffmanTree = firstNode;
|
|
|
|
height = HuffmanHeight_r(firstNode);
|
|
assert(maxHuffmanBits == height);
|
|
}
|
|
|
|
/*
|
|
================
|
|
ShutdownHuffman
|
|
================
|
|
*/
|
|
void ShutdownHuffman(void) {
|
|
if (huffmanTree) {
|
|
FreeHuffmanTree_r(huffmanTree);
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
HuffmanCompressText
|
|
================
|
|
*/
|
|
int HuffmanCompressText(const char* text, int textLength, byte* compressed, int maxCompressedSize) {
|
|
int i, j;
|
|
idBitMsg msg;
|
|
|
|
totalUncompressedLength += textLength;
|
|
|
|
msg.Init(compressed, maxCompressedSize);
|
|
msg.BeginWriting();
|
|
for (i = 0; i < textLength; i++) {
|
|
const huffmanCode_t& code = huffmanCodes[(unsigned char)text[i]];
|
|
for (j = 0; j < (code.numBits >> 5); j++) {
|
|
msg.WriteBits(code.bits[j], 32);
|
|
}
|
|
if (code.numBits & 31) {
|
|
msg.WriteBits(code.bits[j], code.numBits & 31);
|
|
}
|
|
}
|
|
|
|
totalCompressedLength += msg.GetSize();
|
|
|
|
return msg.GetSize();
|
|
}
|
|
|
|
/*
|
|
================
|
|
HuffmanDecompressText
|
|
================
|
|
*/
|
|
int HuffmanDecompressText(char* text, int textLength, const byte* compressed, int compressedSize) {
|
|
int i, bit;
|
|
idBitMsg msg;
|
|
huffmanNode_t* node;
|
|
|
|
msg.Init(compressed, compressedSize);
|
|
msg.SetSize(compressedSize);
|
|
msg.BeginReading();
|
|
for (i = 0; i < textLength; i++) {
|
|
node = huffmanTree;
|
|
do {
|
|
bit = msg.ReadBits(1);
|
|
node = node->children[bit];
|
|
} while (node->symbol == -1);
|
|
text[i] = node->symbol;
|
|
}
|
|
text[i] = '\0';
|
|
return msg.GetReadCount();
|
|
}
|
|
|
|
/*
|
|
================
|
|
ListHuffmanFrequencies_f
|
|
================
|
|
*/
|
|
void ListHuffmanFrequencies_f(const idCmdArgs& args) {
|
|
int i;
|
|
float compression;
|
|
compression = !totalUncompressedLength ? 100 : 100 * totalCompressedLength / totalUncompressedLength;
|
|
common->Printf("// compression ratio = %d%%\n", (int)compression);
|
|
common->Printf("static int huffmanFrequencies[] = {\n");
|
|
for (i = 0; i < MAX_HUFFMAN_SYMBOLS; i += 8) {
|
|
common->Printf("\t0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x,\n",
|
|
huffmanFrequencies[i + 0], huffmanFrequencies[i + 1],
|
|
huffmanFrequencies[i + 2], huffmanFrequencies[i + 3],
|
|
huffmanFrequencies[i + 4], huffmanFrequencies[i + 5],
|
|
huffmanFrequencies[i + 6], huffmanFrequencies[i + 7]);
|
|
}
|
|
common->Printf("}\n");
|
|
}
|
|
|
|
/*
|
|
====================================================================================
|
|
|
|
idDeclFile
|
|
|
|
====================================================================================
|
|
*/
|
|
|
|
/*
|
|
================
|
|
idDeclFile::idDeclFile
|
|
================
|
|
*/
|
|
idDeclFile::idDeclFile(const char* fileName, declType_t defaultType) {
|
|
this->fileName = fileName;
|
|
this->defaultType = defaultType;
|
|
this->timestamp = 0;
|
|
this->checksum = 0;
|
|
this->fileSize = 0;
|
|
this->numLines = 0;
|
|
this->decls = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idDeclFile::idDeclFile
|
|
================
|
|
*/
|
|
idDeclFile::idDeclFile() {
|
|
this->fileName = "<implicit file>";
|
|
this->defaultType = DECL_MAX_TYPES;
|
|
this->timestamp = 0;
|
|
this->checksum = 0;
|
|
this->fileSize = 0;
|
|
this->numLines = 0;
|
|
this->decls = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idDeclFile::Reload
|
|
|
|
ForceReload will cause it to reload even if the timestamp hasn't changed
|
|
================
|
|
*/
|
|
void idDeclFile::Reload(bool force) {
|
|
// check for an unchanged timestamp
|
|
if (!force && timestamp != 0) {
|
|
ID_TIME_T testTimeStamp;
|
|
fileSystem->ReadFile(fileName, NULL, &testTimeStamp);
|
|
|
|
if (testTimeStamp == timestamp) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// parse the text
|
|
LoadAndParse();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idDeclFile::LoadAndParse
|
|
|
|
This is used during both the initial load, and any reloads
|
|
================
|
|
*/
|
|
int c_savedMemory = 0;
|
|
|
|
int idDeclFile::LoadAndParse() {
|
|
int i, numTypes;
|
|
idLexer src;
|
|
idToken token;
|
|
int startMarker;
|
|
char* buffer;
|
|
int length, size;
|
|
int sourceLine;
|
|
idStr name;
|
|
idDeclLocal* newDecl;
|
|
bool reparse;
|
|
|
|
// load the text
|
|
common->DPrintf("...loading '%s'\n", fileName.c_str());
|
|
length = fileSystem->ReadFile(fileName, (void**)&buffer, ×tamp);
|
|
if (length == -1) {
|
|
common->FatalError("couldn't load %s", fileName.c_str());
|
|
return 0;
|
|
}
|
|
|
|
if (!src.LoadMemory(buffer, length, fileName)) {
|
|
common->Error("Couldn't parse %s", fileName.c_str());
|
|
Mem_Free(buffer);
|
|
return 0;
|
|
}
|
|
|
|
// mark all the defs that were from the last reload of this file
|
|
for (idDeclLocal* decl = decls; decl; decl = decl->nextInFile) {
|
|
decl->redefinedInReload = false;
|
|
}
|
|
|
|
src.SetFlags(DECL_LEXER_FLAGS);
|
|
|
|
checksum = MD5_BlockChecksum(buffer, length);
|
|
|
|
fileSize = length;
|
|
|
|
// scan through, identifying each individual declaration
|
|
while (1) {
|
|
|
|
startMarker = src.GetFileOffset();
|
|
sourceLine = src.GetLineNum();
|
|
|
|
// parse the decl type name
|
|
if (!src.ReadToken(&token)) {
|
|
break;
|
|
}
|
|
|
|
#ifdef QUAKE4
|
|
bool guide = false;
|
|
if (token.Icmp("guide") == 0) {
|
|
guide = true;
|
|
if (!src.ReadToken(&token)) {
|
|
src.Warning("Type without definition at end of file");
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
declType_t identifiedType = DECL_MAX_TYPES;
|
|
|
|
// get the decl type from the type name
|
|
numTypes = declManagerLocal.GetNumDeclTypes();
|
|
for (i = 0; i < numTypes; i++) {
|
|
idDeclType* typeInfo = declManagerLocal.GetDeclType(i);
|
|
if (typeInfo && typeInfo->typeName.Icmp(token) == 0) {
|
|
identifiedType = (declType_t)typeInfo->type;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= numTypes) {
|
|
|
|
if (token.Icmp("{") == 0) {
|
|
|
|
// if we ever see an open brace, we somehow missed the [type] <name> prefix
|
|
src.Warning("Missing decl name");
|
|
src.SkipBracedSection(false);
|
|
continue;
|
|
|
|
}
|
|
else {
|
|
|
|
if (defaultType == DECL_MAX_TYPES) {
|
|
src.Warning("No type");
|
|
continue;
|
|
}
|
|
src.UnreadToken(&token);
|
|
// use the default type
|
|
identifiedType = defaultType;
|
|
}
|
|
}
|
|
|
|
// now parse the name
|
|
if (!src.ReadToken(&token)) {
|
|
src.Warning("Type without definition at end of file");
|
|
break;
|
|
}
|
|
|
|
if (!token.Icmp("{")) {
|
|
// if we ever see an open brace, we somehow missed the [type] <name> prefix
|
|
src.Warning("Missing decl name");
|
|
src.SkipBracedSection(false);
|
|
continue;
|
|
}
|
|
|
|
// FIXME: export decls are only used by the model exporter, they are skipped here for now
|
|
if (identifiedType == DECL_MODELEXPORT) {
|
|
src.SkipBracedSection();
|
|
continue;
|
|
}
|
|
|
|
name = token;
|
|
|
|
idStr declDefinition;
|
|
bool useExpandedDefinition = false;
|
|
|
|
#ifdef QUAKE4
|
|
if (guide) {
|
|
if (!declManagerLocal.EvaluateGuide(name, &src, declDefinition)) {
|
|
continue;
|
|
}
|
|
declManagerLocal.EvaluateInlineGuide(name, declDefinition);
|
|
useExpandedDefinition = true;
|
|
size = declDefinition.Length();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// make sure there's a '{'
|
|
if (!src.ReadToken(&token)) {
|
|
src.Warning("Type without definition at end of file");
|
|
break;
|
|
}
|
|
if (token != "{") {
|
|
src.Warning("Expecting '{' but found '%s'", token.c_str());
|
|
continue;
|
|
}
|
|
src.UnreadToken(&token);
|
|
|
|
// now take everything until a matched closing brace
|
|
src.SkipBracedSection();
|
|
size = src.GetFileOffset() - startMarker;
|
|
|
|
#ifdef QUAKE4
|
|
declDefinition = idStr(buffer).Mid(startMarker, size);
|
|
if (declManagerLocal.EvaluateInlineGuide(name, declDefinition)) {
|
|
useExpandedDefinition = true;
|
|
size = declDefinition.Length();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// look it up, possibly getting a newly created default decl
|
|
reparse = false;
|
|
newDecl = declManagerLocal.FindTypeWithoutParsing(identifiedType, name, false);
|
|
if (newDecl) {
|
|
// update the existing copy
|
|
if (newDecl->sourceFile != this || newDecl->redefinedInReload) {
|
|
src.Warning("%s '%s' previously defined at %s:%i", declManagerLocal.GetDeclNameFromType(identifiedType),
|
|
name.c_str(), newDecl->sourceFile->fileName.c_str(), newDecl->sourceLine);
|
|
continue;
|
|
}
|
|
if (newDecl->declState != DS_UNPARSED) {
|
|
reparse = true;
|
|
}
|
|
}
|
|
else {
|
|
// allow it to be created as a default, then add it to the per-file list
|
|
newDecl = declManagerLocal.FindTypeWithoutParsing(identifiedType, name, true);
|
|
newDecl->nextInFile = this->decls;
|
|
this->decls = newDecl;
|
|
}
|
|
|
|
newDecl->redefinedInReload = true;
|
|
|
|
if (newDecl->textSource) {
|
|
Mem_Free(newDecl->textSource);
|
|
newDecl->textSource = NULL;
|
|
}
|
|
|
|
#ifdef QUAKE4
|
|
if (useExpandedDefinition) {
|
|
newDecl->SetTextLocal(declDefinition.c_str(), size);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
newDecl->SetTextLocal(buffer + startMarker, size);
|
|
}
|
|
newDecl->sourceFile = this;
|
|
newDecl->sourceTextOffset = startMarker;
|
|
newDecl->sourceTextLength = size;
|
|
newDecl->sourceLine = sourceLine;
|
|
newDecl->declState = DS_UNPARSED;
|
|
|
|
// if it is currently in use, reparse it immedaitely
|
|
if (reparse) {
|
|
newDecl->ParseLocal();
|
|
}
|
|
}
|
|
|
|
numLines = src.GetLineNum();
|
|
|
|
Mem_Free(buffer);
|
|
|
|
// any defs that weren't redefinedInReload should now be defaulted
|
|
for (idDeclLocal* decl = decls; decl; decl = decl->nextInFile) {
|
|
if (decl->redefinedInReload == false) {
|
|
decl->MakeDefault();
|
|
decl->sourceTextOffset = decl->sourceFile->fileSize;
|
|
decl->sourceTextLength = 0;
|
|
decl->sourceLine = decl->sourceFile->numLines;
|
|
}
|
|
}
|
|
|
|
return checksum;
|
|
}
|
|
|
|
/*
|
|
====================================================================================
|
|
|
|
idDeclManagerLocal
|
|
|
|
====================================================================================
|
|
*/
|
|
|
|
const char* listDeclStrings[] = { "current", "all", "ever", NULL };
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::Init
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::Init(void) {
|
|
|
|
common->Printf("----- Initializing Decls -----\n");
|
|
|
|
checksum = 0;
|
|
|
|
#ifdef USE_COMPRESSED_DECLS
|
|
SetupHuffman();
|
|
#endif
|
|
|
|
#ifdef GET_HUFFMAN_FREQUENCIES
|
|
ClearHuffmanFrequencies();
|
|
#endif
|
|
|
|
#ifdef QUAKE4
|
|
ParseGuides();
|
|
#endif
|
|
|
|
// decls used throughout the engine
|
|
RegisterDeclType("table", DECL_TABLE, idDeclAllocator<idDeclTable>);
|
|
RegisterDeclType("material", DECL_MATERIAL, idDeclAllocator<idMaterial>);
|
|
RegisterDeclType("skin", DECL_SKIN, idDeclAllocator<idDeclSkin>);
|
|
RegisterDeclType("sound", DECL_SOUND, idDeclAllocator<idSoundShader>);
|
|
|
|
RegisterDeclType("entityDef", DECL_ENTITYDEF, idDeclAllocator<idDeclEntityDef>);
|
|
RegisterDeclType("mapDef", DECL_MAPDEF, idDeclAllocator<idDeclEntityDef>);
|
|
RegisterDeclType("fx", DECL_FX, idDeclAllocator<idDeclFX>);
|
|
RegisterDeclType("particle", DECL_PARTICLE, idDeclAllocator<idDeclParticle>);
|
|
RegisterDeclType("articulatedFigure", DECL_AF, idDeclAllocator<idDeclAF>);
|
|
RegisterDeclType("pda", DECL_PDA, idDeclAllocator<idDeclPDA>);
|
|
RegisterDeclType("email", DECL_EMAIL, idDeclAllocator<idDeclEmail>);
|
|
RegisterDeclType("video", DECL_VIDEO, idDeclAllocator<idDeclVideo>);
|
|
RegisterDeclType("audio", DECL_AUDIO, idDeclAllocator<idDeclAudio>);
|
|
|
|
RegisterDeclFolder("materials", ".mtr", DECL_MATERIAL);
|
|
RegisterDeclFolder("skins", ".skin", DECL_SKIN);
|
|
RegisterDeclFolder("sound", ".sndshd", DECL_SOUND);
|
|
|
|
// add console commands
|
|
cmdSystem->AddCommand("listDecls", ListDecls_f, CMD_FL_SYSTEM, "lists all decls");
|
|
|
|
cmdSystem->AddCommand("reloadDecls", ReloadDecls_f, CMD_FL_SYSTEM, "reloads decls");
|
|
cmdSystem->AddCommand("touch", TouchDecl_f, CMD_FL_SYSTEM, "touches a decl");
|
|
|
|
cmdSystem->AddCommand("listTables", idListDecls_f<DECL_TABLE>, CMD_FL_SYSTEM, "lists tables", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listMaterials", idListDecls_f<DECL_MATERIAL>, CMD_FL_SYSTEM, "lists materials", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listSkins", idListDecls_f<DECL_SKIN>, CMD_FL_SYSTEM, "lists skins", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listSoundShaders", idListDecls_f<DECL_SOUND>, CMD_FL_SYSTEM, "lists sound shaders", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
|
|
cmdSystem->AddCommand("listEntityDefs", idListDecls_f<DECL_ENTITYDEF>, CMD_FL_SYSTEM, "lists entity defs", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listFX", idListDecls_f<DECL_FX>, CMD_FL_SYSTEM, "lists FX systems", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listParticles", idListDecls_f<DECL_PARTICLE>, CMD_FL_SYSTEM, "lists particle systems", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listAF", idListDecls_f<DECL_AF>, CMD_FL_SYSTEM, "lists articulated figures", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
|
|
cmdSystem->AddCommand("listPDAs", idListDecls_f<DECL_PDA>, CMD_FL_SYSTEM, "lists PDAs", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listEmails", idListDecls_f<DECL_EMAIL>, CMD_FL_SYSTEM, "lists Emails", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listVideos", idListDecls_f<DECL_VIDEO>, CMD_FL_SYSTEM, "lists Videos", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
cmdSystem->AddCommand("listAudios", idListDecls_f<DECL_AUDIO>, CMD_FL_SYSTEM, "lists Audios", idCmdSystem::ArgCompletion_String<listDeclStrings>);
|
|
|
|
cmdSystem->AddCommand("printTable", idPrintDecls_f<DECL_TABLE>, CMD_FL_SYSTEM, "prints a table", idCmdSystem::ArgCompletion_Decl<DECL_TABLE>);
|
|
cmdSystem->AddCommand("printMaterial", idPrintDecls_f<DECL_MATERIAL>, CMD_FL_SYSTEM, "prints a material", idCmdSystem::ArgCompletion_Decl<DECL_MATERIAL>);
|
|
cmdSystem->AddCommand("printSkin", idPrintDecls_f<DECL_SKIN>, CMD_FL_SYSTEM, "prints a skin", idCmdSystem::ArgCompletion_Decl<DECL_SKIN>);
|
|
cmdSystem->AddCommand("printSoundShader", idPrintDecls_f<DECL_SOUND>, CMD_FL_SYSTEM, "prints a sound shader", idCmdSystem::ArgCompletion_Decl<DECL_SOUND>);
|
|
|
|
cmdSystem->AddCommand("printEntityDef", idPrintDecls_f<DECL_ENTITYDEF>, CMD_FL_SYSTEM, "prints an entity def", idCmdSystem::ArgCompletion_Decl<DECL_ENTITYDEF>);
|
|
cmdSystem->AddCommand("printFX", idPrintDecls_f<DECL_FX>, CMD_FL_SYSTEM, "prints an FX system", idCmdSystem::ArgCompletion_Decl<DECL_FX>);
|
|
cmdSystem->AddCommand("printParticle", idPrintDecls_f<DECL_PARTICLE>, CMD_FL_SYSTEM, "prints a particle system", idCmdSystem::ArgCompletion_Decl<DECL_PARTICLE>);
|
|
cmdSystem->AddCommand("printAF", idPrintDecls_f<DECL_AF>, CMD_FL_SYSTEM, "prints an articulated figure", idCmdSystem::ArgCompletion_Decl<DECL_AF>);
|
|
|
|
cmdSystem->AddCommand("printPDA", idPrintDecls_f<DECL_PDA>, CMD_FL_SYSTEM, "prints an PDA", idCmdSystem::ArgCompletion_Decl<DECL_PDA>);
|
|
cmdSystem->AddCommand("printEmail", idPrintDecls_f<DECL_EMAIL>, CMD_FL_SYSTEM, "prints an Email", idCmdSystem::ArgCompletion_Decl<DECL_EMAIL>);
|
|
cmdSystem->AddCommand("printVideo", idPrintDecls_f<DECL_VIDEO>, CMD_FL_SYSTEM, "prints a Audio", idCmdSystem::ArgCompletion_Decl<DECL_VIDEO>);
|
|
cmdSystem->AddCommand("printAudio", idPrintDecls_f<DECL_AUDIO>, CMD_FL_SYSTEM, "prints an Video", idCmdSystem::ArgCompletion_Decl<DECL_AUDIO>);
|
|
|
|
cmdSystem->AddCommand("listHuffmanFrequencies", ListHuffmanFrequencies_f, CMD_FL_SYSTEM, "lists decl text character frequencies");
|
|
|
|
common->Printf("------------------------------\n");
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::Shutdown
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::Shutdown(void) {
|
|
int i, j;
|
|
idDeclLocal* decl;
|
|
|
|
// free decls
|
|
for (i = 0; i < DECL_MAX_TYPES; i++) {
|
|
for (j = 0; j < linearLists[i].Num(); j++) {
|
|
decl = linearLists[i][j];
|
|
if (decl->self != NULL) {
|
|
decl->self->FreeData();
|
|
delete decl->self;
|
|
}
|
|
if (decl->textSource) {
|
|
Mem_Free(decl->textSource);
|
|
decl->textSource = NULL;
|
|
}
|
|
delete decl;
|
|
}
|
|
linearLists[i].Clear();
|
|
hashTables[i].Free();
|
|
}
|
|
|
|
// free decl files
|
|
loadedFiles.DeleteContents(true);
|
|
|
|
// free the decl types and folders
|
|
declTypes.DeleteContents(true);
|
|
declFolders.DeleteContents(true);
|
|
|
|
#ifdef QUAKE4
|
|
ShutdownGuides();
|
|
#endif
|
|
|
|
#ifdef USE_COMPRESSED_DECLS
|
|
ShutdownHuffman();
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef QUAKE4
|
|
// jmarshall: Quake 4 Guide Support
|
|
/*
|
|
=========================
|
|
idDeclManagerLocal::ParseGuides
|
|
=========================
|
|
*/
|
|
void idDeclManagerLocal::ParseGuides(void) {
|
|
idFileList* fileList = fileSystem->ListFiles("guides", ".guide");
|
|
|
|
guides.Clear();
|
|
common->Printf("Parsing Guides...\n");
|
|
|
|
for (int i = 0; i < fileList->GetNumFiles(); i++) {
|
|
idLexer src;
|
|
idToken token;
|
|
idStr fileName = fileList->GetList()[i];
|
|
|
|
if (!src.LoadFile(va("guides/%s", fileName.c_str()))) {
|
|
continue;
|
|
}
|
|
src.SetFlags(DECL_LEXER_FLAGS);
|
|
|
|
while (!src.EndOfFile()) {
|
|
if (!src.ReadToken(&token) || token.Length() <= 0) {
|
|
break;
|
|
}
|
|
|
|
if (token == "guide" || token == "inlineGuide") {
|
|
rvGuideTemplate guide;
|
|
guide.inlineGuide = (token == "inlineGuide");
|
|
|
|
if (!src.ReadToken(&token)) {
|
|
src.Warning("Guide without name in %s", fileName.c_str());
|
|
break;
|
|
}
|
|
guide.name = token;
|
|
|
|
src.ExpectTokenString("(");
|
|
while (!src.EndOfFile()) {
|
|
if (!src.ReadToken(&token)) {
|
|
break;
|
|
}
|
|
if (token == ")") {
|
|
break;
|
|
}
|
|
if (token == ",") {
|
|
continue;
|
|
}
|
|
guide.parms.Append(token);
|
|
}
|
|
|
|
src.ParseBracedSection(guide.body);
|
|
guides.Append(guide);
|
|
}
|
|
else {
|
|
src.Error("Unexpected token in guide %s\n", token.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
common->Printf("Found %d guides...\n", guides.Num());
|
|
fileSystem->FreeFileList(fileList);
|
|
}
|
|
|
|
/*
|
|
=========================
|
|
idDeclManagerLocal::ShutdownGuides
|
|
=========================
|
|
*/
|
|
void idDeclManagerLocal::ShutdownGuides(void) {
|
|
guides.Clear();
|
|
}
|
|
|
|
static rvGuideTemplate* FindGuideTemplate(idList<rvGuideTemplate>& guides, const char* name, bool inlineOnly) {
|
|
for (int i = 0; i < guides.Num(); i++) {
|
|
if (guides[i].name.Icmp(name) == 0) {
|
|
if (!inlineOnly || guides[i].inlineGuide) {
|
|
return &guides[i];
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void StripGuideBraces(idStr& definition) {
|
|
int first = definition.Find('{');
|
|
if (first == -1) {
|
|
return;
|
|
}
|
|
|
|
int last = -1;
|
|
for (int i = definition.Length() - 1; i > first; i--) {
|
|
if (definition[i] == '}') {
|
|
last = i;
|
|
break;
|
|
}
|
|
}
|
|
if (last <= first) {
|
|
return;
|
|
}
|
|
definition = definition.Mid(first + 1, last - first - 1);
|
|
}
|
|
|
|
static bool ExpandGuideTemplate(rvGuideTemplate* guide, idLexer* src, idStr& definition, const char* declName, bool stripBraces) {
|
|
idToken token;
|
|
idList<idStr> args;
|
|
|
|
if (!src->ExpectTokenString("(")) {
|
|
return false;
|
|
}
|
|
|
|
while (src->ReadToken(&token)) {
|
|
if (token == ")") {
|
|
break;
|
|
}
|
|
if (token == ",") {
|
|
continue;
|
|
}
|
|
args.Append(token);
|
|
}
|
|
|
|
if (args.Num() != guide->parms.Num()) {
|
|
src->Warning("Guide '%s' expects %d parms but got %d in '%s'", guide->name.c_str(), guide->parms.Num(), args.Num(), declName);
|
|
}
|
|
|
|
definition = guide->body;
|
|
if (stripBraces) {
|
|
StripGuideBraces(definition);
|
|
}
|
|
|
|
for (int i = 0; i < guide->parms.Num() && i < args.Num(); i++) {
|
|
definition.Replace(guide->parms[i].c_str(), args[i].c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool idDeclManagerLocal::EvaluateGuide(idStr& name, idLexer* src, idStr& definition) {
|
|
idToken guideName;
|
|
if (!src->ReadToken(&guideName)) {
|
|
return false;
|
|
}
|
|
|
|
rvGuideTemplate* guide = FindGuideTemplate(guides, guideName.c_str(), false);
|
|
if (!guide) {
|
|
src->Warning("Guide name '%s' not found in '%s'", guideName.c_str(), name.c_str());
|
|
src->SkipRestOfLine();
|
|
return false;
|
|
}
|
|
|
|
return ExpandGuideTemplate(guide, src, definition, name.c_str(), false);
|
|
}
|
|
|
|
bool idDeclManagerLocal::EvaluateInlineGuide(idStr& name, idStr& definition) {
|
|
bool replaced = false;
|
|
|
|
while (true) {
|
|
idLexer lexer;
|
|
if (!lexer.LoadMemory(definition.c_str(), definition.Length(), name.c_str())) {
|
|
return replaced;
|
|
}
|
|
lexer.SetFlags(DECL_LEXER_FLAGS);
|
|
|
|
idToken token;
|
|
int tokenStart = 0;
|
|
bool found = false;
|
|
|
|
while (!lexer.EndOfFile()) {
|
|
tokenStart = lexer.GetFileOffset();
|
|
if (!lexer.ReadToken(&token)) {
|
|
break;
|
|
}
|
|
if (token.Icmp("inlineGuide") == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
break;
|
|
}
|
|
|
|
idToken guideName;
|
|
if (!lexer.ReadToken(&guideName)) {
|
|
break;
|
|
}
|
|
|
|
rvGuideTemplate* guide = FindGuideTemplate(guides, guideName.c_str(), true);
|
|
if (!guide) {
|
|
lexer.Warning("Guide name '%s' not found in '%s'", guideName.c_str(), name.c_str());
|
|
return replaced;
|
|
}
|
|
|
|
idStr expanded;
|
|
if (!ExpandGuideTemplate(guide, &lexer, expanded, name.c_str(), true)) {
|
|
return replaced;
|
|
}
|
|
|
|
int tokenEnd = lexer.GetFileOffset();
|
|
idStr prefix = definition.Mid(0, tokenStart);
|
|
idStr suffix = definition.Mid(tokenEnd, definition.Length() - tokenEnd);
|
|
definition = prefix + expanded + suffix;
|
|
replaced = true;
|
|
}
|
|
|
|
return replaced;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::Reload
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::Reload(bool force) {
|
|
for (int i = 0; i < loadedFiles.Num(); i++) {
|
|
loadedFiles[i]->Reload(force);
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::BeginLevelLoad
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::BeginLevelLoad() {
|
|
insideLevelLoad = true;
|
|
|
|
// clear all the referencedThisLevel flags and purge all the data
|
|
// so the next reference will cause a reparse
|
|
for (int i = 0; i < DECL_MAX_TYPES; i++) {
|
|
int num = linearLists[i].Num();
|
|
for (int j = 0; j < num; j++) {
|
|
idDeclLocal* decl = linearLists[i][j];
|
|
decl->Purge();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::EndLevelLoad
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::EndLevelLoad() {
|
|
insideLevelLoad = false;
|
|
|
|
// we don't need to do anything here, but the image manager, model manager,
|
|
// and sound sample manager will need to free media that was not referenced
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::RegisterDeclType
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::RegisterDeclType(const char* typeName, declType_t type, idDecl* (*allocator)(void)) {
|
|
idDeclType* declType;
|
|
|
|
if (type < declTypes.Num() && declTypes[(int)type]) {
|
|
common->Warning("idDeclManager::RegisterDeclType: type '%s' already exists", typeName);
|
|
return;
|
|
}
|
|
|
|
declType = new idDeclType;
|
|
declType->typeName = typeName;
|
|
declType->type = type;
|
|
declType->allocator = allocator;
|
|
|
|
if ((int)type + 1 > declTypes.Num()) {
|
|
declTypes.AssureSize((int)type + 1, NULL);
|
|
}
|
|
declTypes[type] = declType;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
RegisterDeclSubFolder
|
|
===================
|
|
*/
|
|
// jmarshall
|
|
void idDeclManagerLocal::RegisterDeclSubFolder(const char* folder, const char* extension, idList<idStr>& fileList) {
|
|
// Find all
|
|
{
|
|
idFileList* list = fileSystem->ListFiles(folder, extension, true);
|
|
|
|
for (int d = 0; d < list->GetNumFiles(); d++)
|
|
{
|
|
fileList.Append(va("%s/%s", folder, list->GetFile(d)));
|
|
}
|
|
|
|
fileSystem->FreeFileList(list);
|
|
}
|
|
|
|
idFileList* dirList = fileSystem->ListFiles(folder, "/", true);
|
|
for (int i = 0; i < dirList->GetNumFiles(); i++)
|
|
{
|
|
idStr dir = va("%s/%s", folder, dirList->GetFile(i));
|
|
RegisterDeclSubFolder(dir, extension, fileList);
|
|
}
|
|
|
|
fileSystem->FreeFileList(dirList);
|
|
}
|
|
// jmarshall end
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::RegisterDeclFolder
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::RegisterDeclFolder(const char* folder, const char* extension, declType_t defaultType) {
|
|
int i, j;
|
|
idStr fileName;
|
|
idDeclFolder* declFolder;
|
|
// jmarshall - decls subfolders
|
|
idList<idStr> fileList;
|
|
// jmarshall end
|
|
idDeclFile* df;
|
|
|
|
// check whether this folder / extension combination already exists
|
|
for (i = 0; i < declFolders.Num(); i++) {
|
|
if (declFolders[i]->folder.Icmp(folder) == 0 && declFolders[i]->extension.Icmp(extension) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (i < declFolders.Num()) {
|
|
declFolder = declFolders[i];
|
|
}
|
|
else {
|
|
declFolder = new idDeclFolder;
|
|
declFolder->folder = folder;
|
|
declFolder->extension = extension;
|
|
declFolder->defaultType = defaultType;
|
|
declFolders.Append(declFolder);
|
|
}
|
|
|
|
// jmarshall - decls subfolders
|
|
RegisterDeclSubFolder(declFolder->folder, declFolder->extension, fileList);
|
|
// jmarshall end
|
|
|
|
// load and parse decl files
|
|
for (i = 0; i < fileList.Num(); i++) {
|
|
// jmarshall
|
|
//fileName = declFolder->folder + "/" + fileList[ i ];
|
|
fileName = fileList[i];
|
|
// jmarshall end
|
|
|
|
// check whether this file has already been loaded
|
|
for (j = 0; j < loadedFiles.Num(); j++) {
|
|
if (fileName.Icmp(loadedFiles[j]->fileName) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (j < loadedFiles.Num()) {
|
|
df = loadedFiles[j];
|
|
}
|
|
else {
|
|
df = new idDeclFile(fileName, defaultType);
|
|
loadedFiles.Append(df);
|
|
}
|
|
df->LoadAndParse();
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::GetChecksum
|
|
===================
|
|
*/
|
|
int idDeclManagerLocal::GetChecksum(void) const {
|
|
int i, j, total, num;
|
|
int* checksumData;
|
|
|
|
// get the total number of decls
|
|
total = 0;
|
|
for (i = 0; i < DECL_MAX_TYPES; i++) {
|
|
total += linearLists[i].Num();
|
|
}
|
|
|
|
checksumData = (int*)_alloca16(total * 2 * sizeof(int));
|
|
|
|
total = 0;
|
|
for (i = 0; i < DECL_MAX_TYPES; i++) {
|
|
declType_t type = (declType_t)i;
|
|
|
|
// FIXME: not particularly pretty but PDAs and associated decls are localized and should not be checksummed
|
|
if (type == DECL_PDA || type == DECL_VIDEO || type == DECL_AUDIO || type == DECL_EMAIL) {
|
|
continue;
|
|
}
|
|
|
|
num = linearLists[i].Num();
|
|
for (j = 0; j < num; j++) {
|
|
idDeclLocal* decl = linearLists[i][j];
|
|
|
|
if (decl->sourceFile == &implicitDecls) {
|
|
continue;
|
|
}
|
|
|
|
checksumData[total * 2 + 0] = total;
|
|
checksumData[total * 2 + 1] = decl->checksum;
|
|
total++;
|
|
}
|
|
}
|
|
|
|
LittleRevBytes(checksumData, sizeof(int), total * 2);
|
|
return MD5_BlockChecksum(checksumData, total * 2 * sizeof(int));
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::GetNumDeclTypes
|
|
===================
|
|
*/
|
|
int idDeclManagerLocal::GetNumDeclTypes(void) const {
|
|
return declTypes.Num();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::GetDeclNameFromType
|
|
===================
|
|
*/
|
|
const char* idDeclManagerLocal::GetDeclNameFromType(declType_t type) const {
|
|
int typeIndex = (int)type;
|
|
|
|
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
|
|
common->FatalError("idDeclManager::GetDeclNameFromType: bad type: %i", typeIndex);
|
|
}
|
|
return declTypes[typeIndex]->typeName;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::GetDeclTypeFromName
|
|
===================
|
|
*/
|
|
declType_t idDeclManagerLocal::GetDeclTypeFromName(const char* typeName) const {
|
|
int i;
|
|
|
|
for (i = 0; i < declTypes.Num(); i++) {
|
|
if (declTypes[i] && declTypes[i]->typeName.Icmp(typeName) == 0) {
|
|
return (declType_t)declTypes[i]->type;
|
|
}
|
|
}
|
|
return DECL_MAX_TYPES;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclManagerLocal::FindType
|
|
|
|
External users will always cause the decl to be parsed before returning
|
|
=================
|
|
*/
|
|
const idDecl* idDeclManagerLocal::FindType(declType_t type, const char* name, bool makeDefault) {
|
|
idDeclLocal* decl;
|
|
|
|
if (!name || !name[0]) {
|
|
name = "_emptyName";
|
|
//common->Warning( "idDeclManager::FindType: empty %s name", GetDeclType( (int)type )->typeName.c_str() );
|
|
}
|
|
|
|
decl = FindTypeWithoutParsing(type, name, makeDefault);
|
|
if (!decl) {
|
|
return NULL;
|
|
}
|
|
|
|
decl->AllocateSelf();
|
|
|
|
// if it hasn't been parsed yet, parse it now
|
|
if (decl->declState == DS_UNPARSED) {
|
|
decl->ParseLocal();
|
|
}
|
|
|
|
// mark it as referenced
|
|
decl->referencedThisLevel = true;
|
|
decl->everReferenced = true;
|
|
if (insideLevelLoad) {
|
|
decl->parsedOutsideLevelLoad = false;
|
|
}
|
|
|
|
return decl->self;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idDeclManagerLocal::FindDeclWithoutParsing
|
|
===============
|
|
*/
|
|
const idDecl* idDeclManagerLocal::FindDeclWithoutParsing(declType_t type, const char* name, bool makeDefault) {
|
|
idDeclLocal* decl;
|
|
decl = FindTypeWithoutParsing(type, name, makeDefault);
|
|
if (decl) {
|
|
return decl->self;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idDeclManagerLocal::ReloadFile
|
|
===============
|
|
*/
|
|
void idDeclManagerLocal::ReloadFile(const char* filename, bool force) {
|
|
for (int i = 0; i < loadedFiles.Num(); i++) {
|
|
if (!loadedFiles[i]->fileName.Icmp(filename)) {
|
|
checksum ^= loadedFiles[i]->checksum;
|
|
loadedFiles[i]->Reload(force);
|
|
checksum ^= loadedFiles[i]->checksum;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::GetNumDecls
|
|
===================
|
|
*/
|
|
int idDeclManagerLocal::GetNumDecls(declType_t type) {
|
|
int typeIndex = (int)type;
|
|
|
|
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
|
|
common->FatalError("idDeclManager::GetNumDecls: bad type: %i", typeIndex);
|
|
}
|
|
return linearLists[typeIndex].Num();
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::DeclByIndex
|
|
===================
|
|
*/
|
|
const idDecl* idDeclManagerLocal::DeclByIndex(declType_t type, int index, bool forceParse) {
|
|
int typeIndex = (int)type;
|
|
|
|
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
|
|
common->FatalError("idDeclManager::DeclByIndex: bad type: %i", typeIndex);
|
|
}
|
|
if (index < 0 || index >= linearLists[typeIndex].Num()) {
|
|
common->Error("idDeclManager::DeclByIndex: out of range");
|
|
}
|
|
idDeclLocal* decl = linearLists[typeIndex][index];
|
|
|
|
decl->AllocateSelf();
|
|
|
|
if (forceParse && decl->declState == DS_UNPARSED) {
|
|
decl->ParseLocal();
|
|
}
|
|
|
|
return decl->self;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::ListType
|
|
|
|
list*
|
|
Lists decls currently referenced
|
|
|
|
list* ever
|
|
Lists decls that have been referenced at least once since app launched
|
|
|
|
list* all
|
|
Lists every decl declared, even if it hasn't been referenced or parsed
|
|
|
|
FIXME: alphabetized, wildcards?
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::ListType(const idCmdArgs& args, declType_t type) {
|
|
bool all, ever;
|
|
|
|
if (!idStr::Icmp(args.Argv(1), "all")) {
|
|
all = true;
|
|
}
|
|
else {
|
|
all = false;
|
|
}
|
|
if (!idStr::Icmp(args.Argv(1), "ever")) {
|
|
ever = true;
|
|
}
|
|
else {
|
|
ever = false;
|
|
}
|
|
|
|
common->Printf("--------------------\n");
|
|
int printed = 0;
|
|
int count = linearLists[(int)type].Num();
|
|
for (int i = 0; i < count; i++) {
|
|
idDeclLocal* decl = linearLists[(int)type][i];
|
|
|
|
if (!all && decl->declState == DS_UNPARSED) {
|
|
continue;
|
|
}
|
|
|
|
if (!all && !ever && !decl->referencedThisLevel) {
|
|
continue;
|
|
}
|
|
|
|
if (decl->referencedThisLevel) {
|
|
common->Printf("*");
|
|
}
|
|
else if (decl->everReferenced) {
|
|
common->Printf(".");
|
|
}
|
|
else {
|
|
common->Printf(" ");
|
|
}
|
|
if (decl->declState == DS_DEFAULTED) {
|
|
common->Printf("D");
|
|
}
|
|
else {
|
|
common->Printf(" ");
|
|
}
|
|
common->Printf("%4i: ", decl->index);
|
|
printed++;
|
|
if (decl->declState == DS_UNPARSED) {
|
|
// doesn't have any type specific data yet
|
|
common->Printf("%s\n", decl->GetName());
|
|
}
|
|
else {
|
|
decl->self->List();
|
|
}
|
|
}
|
|
|
|
common->Printf("--------------------\n");
|
|
common->Printf("%i of %i %s\n", printed, count, declTypes[type]->typeName.c_str());
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::PrintType
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::PrintType(const idCmdArgs& args, declType_t type) {
|
|
// individual decl types may use additional command parameters
|
|
if (args.Argc() < 2) {
|
|
common->Printf("USAGE: Print<decl type> <decl name> [type specific parms]\n");
|
|
return;
|
|
}
|
|
|
|
// look it up, skipping the public path so it won't parse or reference
|
|
idDeclLocal* decl = FindTypeWithoutParsing(type, args.Argv(1), false);
|
|
if (!decl) {
|
|
common->Printf("%s '%s' not found.\n", declTypes[type]->typeName.c_str(), args.Argv(1));
|
|
return;
|
|
}
|
|
|
|
// print information common to all decls
|
|
common->Printf("%s %s:\n", declTypes[type]->typeName.c_str(), decl->name.c_str());
|
|
common->Printf("source: %s:%i\n", decl->sourceFile->fileName.c_str(), decl->sourceLine);
|
|
common->Printf("----------\n");
|
|
if (decl->textSource != NULL) {
|
|
char* declText = (char*)_alloca(decl->textLength + 1);
|
|
decl->GetText(declText);
|
|
common->Printf("%s\n", declText);
|
|
}
|
|
else {
|
|
common->Printf("NO SOURCE\n");
|
|
}
|
|
common->Printf("----------\n");
|
|
switch (decl->declState) {
|
|
case DS_UNPARSED:
|
|
common->Printf("Unparsed.\n");
|
|
break;
|
|
case DS_DEFAULTED:
|
|
common->Printf("<DEFAULTED>\n");
|
|
break;
|
|
case DS_PARSED:
|
|
common->Printf("Parsed.\n");
|
|
break;
|
|
}
|
|
|
|
if (decl->referencedThisLevel) {
|
|
common->Printf("Currently referenced this level.\n");
|
|
}
|
|
else if (decl->everReferenced) {
|
|
common->Printf("Referenced in a previous level.\n");
|
|
}
|
|
else {
|
|
common->Printf("Never referenced.\n");
|
|
}
|
|
|
|
// allow type-specific data to be printed
|
|
if (decl->self != NULL) {
|
|
decl->self->Print();
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::CreateNewDecl
|
|
===================
|
|
*/
|
|
idDecl* idDeclManagerLocal::CreateNewDecl(declType_t type, const char* name, const char* _fileName) {
|
|
int typeIndex = (int)type;
|
|
int i, hash;
|
|
|
|
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
|
|
common->FatalError("idDeclManager::CreateNewDecl: bad type: %i", typeIndex);
|
|
}
|
|
|
|
char canonicalName[MAX_STRING_CHARS];
|
|
|
|
MakeNameCanonical(name, canonicalName, sizeof(canonicalName));
|
|
|
|
idStr fileName = _fileName;
|
|
fileName.BackSlashesToSlashes();
|
|
|
|
// see if it already exists
|
|
hash = hashTables[typeIndex].GenerateKey(canonicalName, false);
|
|
for (i = hashTables[typeIndex].First(hash); i >= 0; i = hashTables[typeIndex].Next(i)) {
|
|
if (linearLists[typeIndex][i]->name.Icmp(canonicalName) == 0) {
|
|
linearLists[typeIndex][i]->AllocateSelf();
|
|
return linearLists[typeIndex][i]->self;
|
|
}
|
|
}
|
|
|
|
idDeclFile* sourceFile;
|
|
|
|
// find existing source file or create a new one
|
|
for (i = 0; i < loadedFiles.Num(); i++) {
|
|
if (loadedFiles[i]->fileName.Icmp(fileName) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (i < loadedFiles.Num()) {
|
|
sourceFile = loadedFiles[i];
|
|
}
|
|
else {
|
|
sourceFile = new idDeclFile(fileName, type);
|
|
loadedFiles.Append(sourceFile);
|
|
}
|
|
|
|
idDeclLocal* decl = new idDeclLocal;
|
|
decl->name = canonicalName;
|
|
decl->type = type;
|
|
decl->declState = DS_UNPARSED;
|
|
decl->AllocateSelf();
|
|
idStr header = declTypes[typeIndex]->typeName;
|
|
idStr defaultText = decl->self->DefaultDefinition();
|
|
|
|
|
|
int size = header.Length() + 1 + idStr::Length(canonicalName) + 1 + defaultText.Length();
|
|
char* declText = (char*)_alloca(size + 1);
|
|
|
|
memcpy(declText, header, header.Length());
|
|
declText[header.Length()] = ' ';
|
|
memcpy(declText + header.Length() + 1, canonicalName, idStr::Length(canonicalName));
|
|
declText[header.Length() + 1 + idStr::Length(canonicalName)] = ' ';
|
|
memcpy(declText + header.Length() + 1 + idStr::Length(canonicalName) + 1, defaultText, defaultText.Length() + 1);
|
|
|
|
decl->SetTextLocal(declText, size);
|
|
decl->sourceFile = sourceFile;
|
|
decl->sourceTextOffset = sourceFile->fileSize;
|
|
decl->sourceTextLength = 0;
|
|
decl->sourceLine = sourceFile->numLines;
|
|
|
|
decl->ParseLocal();
|
|
|
|
// add this decl to the source file list
|
|
decl->nextInFile = sourceFile->decls;
|
|
sourceFile->decls = decl;
|
|
|
|
// add it to the hash table and linear list
|
|
decl->index = linearLists[typeIndex].Num();
|
|
hashTables[typeIndex].Add(hash, linearLists[typeIndex].Append(decl));
|
|
|
|
return decl->self;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idDeclManagerLocal::RenameDecl
|
|
===============
|
|
*/
|
|
bool idDeclManagerLocal::RenameDecl(declType_t type, const char* oldName, const char* newName) {
|
|
|
|
char canonicalOldName[MAX_STRING_CHARS];
|
|
MakeNameCanonical(oldName, canonicalOldName, sizeof(canonicalOldName));
|
|
|
|
char canonicalNewName[MAX_STRING_CHARS];
|
|
MakeNameCanonical(newName, canonicalNewName, sizeof(canonicalNewName));
|
|
|
|
idDeclLocal* decl = NULL;
|
|
|
|
// make sure it already exists
|
|
int typeIndex = (int)type;
|
|
int i, hash;
|
|
hash = hashTables[typeIndex].GenerateKey(canonicalOldName, false);
|
|
for (i = hashTables[typeIndex].First(hash); i >= 0; i = hashTables[typeIndex].Next(i)) {
|
|
if (linearLists[typeIndex][i]->name.Icmp(canonicalOldName) == 0) {
|
|
decl = linearLists[typeIndex][i];
|
|
break;
|
|
}
|
|
}
|
|
if (!decl)
|
|
return false;
|
|
|
|
//if ( !hashTables[(int)type].Get( canonicalOldName, &declPtr ) )
|
|
// return false;
|
|
|
|
//decl = *declPtr;
|
|
|
|
//Change the name
|
|
decl->name = canonicalNewName;
|
|
|
|
|
|
// add it to the hash table
|
|
//hashTables[(int)decl->type].Set( decl->name, decl );
|
|
int newhash = hashTables[typeIndex].GenerateKey(canonicalNewName, false);
|
|
hashTables[typeIndex].Add(newhash, decl->index);
|
|
|
|
//Remove the old hash item
|
|
hashTables[typeIndex].Remove(hash, decl->index);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::MediaPrint
|
|
|
|
This is just used to nicely indent media caching prints
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::MediaPrint(const char* fmt, ...) {
|
|
if (!decl_show.GetInteger()) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < indent; i++) {
|
|
common->Printf(" ");
|
|
}
|
|
va_list argptr;
|
|
char buffer[1024];
|
|
va_start(argptr, fmt);
|
|
idStr::vsnPrintf(buffer, sizeof(buffer), fmt, argptr);
|
|
va_end(argptr);
|
|
buffer[sizeof(buffer) - 1] = '\0';
|
|
|
|
common->Printf("%s", buffer);
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::WritePrecacheCommands
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::WritePrecacheCommands(idFile* f) {
|
|
for (int i = 0; i < declTypes.Num(); i++) {
|
|
int num;
|
|
|
|
if (declTypes[i] == NULL) {
|
|
continue;
|
|
}
|
|
|
|
num = linearLists[i].Num();
|
|
|
|
for (int j = 0; j < num; j++) {
|
|
idDeclLocal* decl = linearLists[i][j];
|
|
|
|
if (!decl->referencedThisLevel) {
|
|
continue;
|
|
}
|
|
|
|
char str[1024];
|
|
sprintf(str, "touch %s %s\n", declTypes[i]->typeName.c_str(), decl->GetName());
|
|
common->Printf("%s", str);
|
|
f->Printf("%s", str);
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************/
|
|
|
|
const idMaterial* idDeclManagerLocal::FindMaterial(const char* name, bool makeDefault) {
|
|
return static_cast<const idMaterial*>(FindType(DECL_MATERIAL, name, makeDefault));
|
|
}
|
|
|
|
const idMaterial* idDeclManagerLocal::MaterialByIndex(int index, bool forceParse) {
|
|
return static_cast<const idMaterial*>(DeclByIndex(DECL_MATERIAL, index, forceParse));
|
|
}
|
|
|
|
/********************************************************************/
|
|
|
|
const idDeclSkin* idDeclManagerLocal::FindSkin(const char* name, bool makeDefault) {
|
|
return static_cast<const idDeclSkin*>(FindType(DECL_SKIN, name, makeDefault));
|
|
}
|
|
|
|
const idDeclSkin* idDeclManagerLocal::SkinByIndex(int index, bool forceParse) {
|
|
return static_cast<const idDeclSkin*>(DeclByIndex(DECL_SKIN, index, forceParse));
|
|
}
|
|
|
|
/********************************************************************/
|
|
|
|
const idSoundShader* idDeclManagerLocal::FindSound(const char* name, bool makeDefault) {
|
|
return static_cast<const idSoundShader*>(FindType(DECL_SOUND, name, makeDefault));
|
|
}
|
|
|
|
const idSoundShader* idDeclManagerLocal::SoundByIndex(int index, bool forceParse) {
|
|
return static_cast<const idSoundShader*>(DeclByIndex(DECL_SOUND, index, forceParse));
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::MakeNameCanonical
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::MakeNameCanonical(const char* name, char* result, int maxLength) {
|
|
int i, lastDot;
|
|
|
|
lastDot = -1;
|
|
for (i = 0; i < maxLength && name[i] != '\0'; i++) {
|
|
int c = name[i];
|
|
if (c == '\\') {
|
|
result[i] = '/';
|
|
}
|
|
else if (c == '.') {
|
|
lastDot = i;
|
|
result[i] = c;
|
|
}
|
|
else {
|
|
result[i] = idStr::ToLower(c);
|
|
}
|
|
}
|
|
if (lastDot != -1) {
|
|
result[lastDot] = '\0';
|
|
}
|
|
else {
|
|
result[i] = '\0';
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idDeclManagerLocal::ListDecls_f
|
|
================
|
|
*/
|
|
void idDeclManagerLocal::ListDecls_f(const idCmdArgs& args) {
|
|
int i, j;
|
|
int totalDecls = 0;
|
|
int totalText = 0;
|
|
int totalStructs = 0;
|
|
|
|
for (i = 0; i < declManagerLocal.declTypes.Num(); i++) {
|
|
int size, num;
|
|
|
|
if (declManagerLocal.declTypes[i] == NULL) {
|
|
continue;
|
|
}
|
|
|
|
num = declManagerLocal.linearLists[i].Num();
|
|
totalDecls += num;
|
|
|
|
size = 0;
|
|
for (j = 0; j < num; j++) {
|
|
size += declManagerLocal.linearLists[i][j]->Size();
|
|
if (declManagerLocal.linearLists[i][j]->self != NULL) {
|
|
size += declManagerLocal.linearLists[i][j]->self->Size();
|
|
}
|
|
}
|
|
totalStructs += size;
|
|
|
|
common->Printf("%4ik %4i %s\n", size >> 10, num, declManagerLocal.declTypes[i]->typeName.c_str());
|
|
}
|
|
|
|
for (i = 0; i < declManagerLocal.loadedFiles.Num(); i++) {
|
|
idDeclFile* df = declManagerLocal.loadedFiles[i];
|
|
totalText += df->fileSize;
|
|
}
|
|
|
|
common->Printf("%i total decls is %i decl files\n", totalDecls, declManagerLocal.loadedFiles.Num());
|
|
common->Printf("%iKB in text, %iKB in structures\n", totalText >> 10, totalStructs >> 10);
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::ReloadDecls_f
|
|
|
|
Reload will not find any new files created in the directories, it
|
|
will only reload existing files.
|
|
|
|
A reload will never cause anything to be purged.
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::ReloadDecls_f(const idCmdArgs& args) {
|
|
bool force;
|
|
|
|
if (!idStr::Icmp(args.Argv(1), "all")) {
|
|
force = true;
|
|
common->Printf("reloading all decl files:\n");
|
|
}
|
|
else {
|
|
force = false;
|
|
common->Printf("reloading changed decl files:\n");
|
|
}
|
|
|
|
soundSystem->SetMute(true);
|
|
|
|
declManagerLocal.Reload(force);
|
|
|
|
soundSystem->SetMute(false);
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::TouchDecl_f
|
|
===================
|
|
*/
|
|
void idDeclManagerLocal::TouchDecl_f(const idCmdArgs& args) {
|
|
int i;
|
|
|
|
if (args.Argc() != 3) {
|
|
common->Printf("usage: touch <type> <name>\n");
|
|
common->Printf("valid types: ");
|
|
for (int i = 0; i < declManagerLocal.declTypes.Num(); i++) {
|
|
if (declManagerLocal.declTypes[i]) {
|
|
common->Printf("%s ", declManagerLocal.declTypes[i]->typeName.c_str());
|
|
}
|
|
}
|
|
common->Printf("\n");
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < declManagerLocal.declTypes.Num(); i++) {
|
|
if (declManagerLocal.declTypes[i] && declManagerLocal.declTypes[i]->typeName.Icmp(args.Argv(1)) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (i >= declManagerLocal.declTypes.Num()) {
|
|
common->Printf("unknown decl type '%s'\n", args.Argv(1));
|
|
return;
|
|
}
|
|
|
|
const idDecl* decl = declManagerLocal.FindType((declType_t)i, args.Argv(2), false);
|
|
if (!decl) {
|
|
common->Printf("%s '%s' not found\n", declManagerLocal.declTypes[i]->typeName.c_str(), args.Argv(2));
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idDeclManagerLocal::FindTypeWithoutParsing
|
|
|
|
This finds or creats the decl, but does not cause a parse. This is only used internally.
|
|
===================
|
|
*/
|
|
idDeclLocal* idDeclManagerLocal::FindTypeWithoutParsing(declType_t type, const char* name, bool makeDefault) {
|
|
int typeIndex = (int)type;
|
|
int i, hash;
|
|
|
|
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
|
|
common->FatalError("idDeclManager::FindTypeWithoutParsing: bad type: %i", typeIndex);
|
|
}
|
|
|
|
char canonicalName[MAX_STRING_CHARS];
|
|
|
|
MakeNameCanonical(name, canonicalName, sizeof(canonicalName));
|
|
|
|
// see if it already exists
|
|
hash = hashTables[typeIndex].GenerateKey(canonicalName, false);
|
|
for (i = hashTables[typeIndex].First(hash); i >= 0; i = hashTables[typeIndex].Next(i)) {
|
|
if (linearLists[typeIndex][i]->name.Icmp(canonicalName) == 0) {
|
|
// only print these when decl_show is set to 2, because it can be a lot of clutter
|
|
if (decl_show.GetInteger() > 1) {
|
|
MediaPrint("referencing %s %s\n", declTypes[type]->typeName.c_str(), name);
|
|
}
|
|
return linearLists[typeIndex][i];
|
|
}
|
|
}
|
|
|
|
if (!makeDefault) {
|
|
return NULL;
|
|
}
|
|
|
|
idDeclLocal* decl = new idDeclLocal;
|
|
decl->self = NULL;
|
|
decl->name = canonicalName;
|
|
decl->type = type;
|
|
decl->declState = DS_UNPARSED;
|
|
decl->textSource = NULL;
|
|
decl->textLength = 0;
|
|
decl->sourceFile = &implicitDecls;
|
|
decl->referencedThisLevel = false;
|
|
decl->everReferenced = false;
|
|
decl->parsedOutsideLevelLoad = !insideLevelLoad;
|
|
|
|
// add it to the linear list and hash table
|
|
decl->index = linearLists[typeIndex].Num();
|
|
hashTables[typeIndex].Add(hash, linearLists[typeIndex].Append(decl));
|
|
|
|
return decl;
|
|
}
|
|
|
|
|
|
/*
|
|
====================================================================================
|
|
|
|
idDeclLocal
|
|
|
|
====================================================================================
|
|
*/
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::idDeclLocal
|
|
=================
|
|
*/
|
|
idDeclLocal::idDeclLocal(void) {
|
|
name = "unnamed";
|
|
textSource = NULL;
|
|
textLength = 0;
|
|
compressedLength = 0;
|
|
sourceFile = NULL;
|
|
sourceTextOffset = 0;
|
|
sourceTextLength = 0;
|
|
sourceLine = 0;
|
|
checksum = 0;
|
|
type = DECL_ENTITYDEF;
|
|
index = 0;
|
|
declState = DS_UNPARSED;
|
|
parsedOutsideLevelLoad = false;
|
|
referencedThisLevel = false;
|
|
everReferenced = false;
|
|
redefinedInReload = false;
|
|
nextInFile = NULL;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetName
|
|
=================
|
|
*/
|
|
const char* idDeclLocal::GetName(void) const {
|
|
return name.c_str();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetType
|
|
=================
|
|
*/
|
|
declType_t idDeclLocal::GetType(void) const {
|
|
return type;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetState
|
|
=================
|
|
*/
|
|
declState_t idDeclLocal::GetState(void) const {
|
|
return declState;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::IsImplicit
|
|
=================
|
|
*/
|
|
bool idDeclLocal::IsImplicit(void) const {
|
|
return (sourceFile == declManagerLocal.GetImplicitDeclFile());
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::IsValid
|
|
=================
|
|
*/
|
|
bool idDeclLocal::IsValid(void) const {
|
|
return (declState != DS_UNPARSED);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Invalidate
|
|
=================
|
|
*/
|
|
void idDeclLocal::Invalidate(void) {
|
|
declState = DS_UNPARSED;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::EnsureNotPurged
|
|
=================
|
|
*/
|
|
void idDeclLocal::EnsureNotPurged(void) {
|
|
if (declState == DS_UNPARSED) {
|
|
ParseLocal();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Index
|
|
=================
|
|
*/
|
|
int idDeclLocal::Index(void) const {
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetLineNum
|
|
=================
|
|
*/
|
|
int idDeclLocal::GetLineNum(void) const {
|
|
return sourceLine;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetFileName
|
|
=================
|
|
*/
|
|
const char* idDeclLocal::GetFileName(void) const {
|
|
return (sourceFile) ? sourceFile->fileName.c_str() : "*invalid*";
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Size
|
|
=================
|
|
*/
|
|
size_t idDeclLocal::Size(void) const {
|
|
return sizeof(idDecl) + name.Allocated();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetText
|
|
=================
|
|
*/
|
|
void idDeclLocal::GetText(char* text) const {
|
|
#ifdef USE_COMPRESSED_DECLS
|
|
HuffmanDecompressText(text, textLength, (byte*)textSource, compressedLength);
|
|
#else
|
|
memcpy(text, textSource, textLength + 1);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::GetTextLength
|
|
=================
|
|
*/
|
|
int idDeclLocal::GetTextLength(void) const {
|
|
return textLength;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::SetText
|
|
=================
|
|
*/
|
|
void idDeclLocal::SetText(const char* text) {
|
|
SetTextLocal(text, idStr::Length(text));
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::SetTextLocal
|
|
=================
|
|
*/
|
|
void idDeclLocal::SetTextLocal(const char* text, const int length) {
|
|
|
|
Mem_Free(textSource);
|
|
|
|
checksum = MD5_BlockChecksum(text, length);
|
|
|
|
#ifdef GET_HUFFMAN_FREQUENCIES
|
|
for (int i = 0; i < length; i++) {
|
|
huffmanFrequencies[((const unsigned char*)text)[i]]++;
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_COMPRESSED_DECLS
|
|
int maxBytesPerCode = (maxHuffmanBits + 7) >> 3;
|
|
byte* compressed = (byte*)_alloca(length * maxBytesPerCode);
|
|
compressedLength = HuffmanCompressText(text, length, compressed, length * maxBytesPerCode);
|
|
textSource = (char*)Mem_Alloc(compressedLength);
|
|
memcpy(textSource, compressed, compressedLength);
|
|
#else
|
|
compressedLength = length;
|
|
textSource = (char*)Mem_Alloc(length + 1);
|
|
memcpy(textSource, text, length);
|
|
textSource[length] = '\0';
|
|
#endif
|
|
textLength = length;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::ReplaceSourceFileText
|
|
=================
|
|
*/
|
|
bool idDeclLocal::ReplaceSourceFileText(void) {
|
|
int oldFileLength, newFileLength;
|
|
char* buffer;
|
|
idFile* file;
|
|
|
|
common->Printf("Writing \'%s\' to \'%s\'...\n", GetName(), GetFileName());
|
|
|
|
if (sourceFile == &declManagerLocal.implicitDecls) {
|
|
common->Warning("Can't save implicit declaration %s.", GetName());
|
|
return false;
|
|
}
|
|
|
|
// get length and allocate buffer to hold the file
|
|
oldFileLength = sourceFile->fileSize;
|
|
newFileLength = oldFileLength - sourceTextLength + textLength;
|
|
buffer = (char*)Mem_Alloc(Max(newFileLength, oldFileLength));
|
|
|
|
// read original file
|
|
if (sourceFile->fileSize) {
|
|
|
|
file = fileSystem->OpenFileRead(GetFileName());
|
|
if (!file) {
|
|
Mem_Free(buffer);
|
|
common->Warning("Couldn't open %s for reading.", GetFileName());
|
|
return false;
|
|
}
|
|
|
|
if (file->Length() != sourceFile->fileSize || file->Timestamp() != sourceFile->timestamp) {
|
|
Mem_Free(buffer);
|
|
common->Warning("The file %s has been modified outside of the engine.", GetFileName());
|
|
return false;
|
|
}
|
|
|
|
file->Read(buffer, oldFileLength);
|
|
fileSystem->CloseFile(file);
|
|
|
|
if (MD5_BlockChecksum(buffer, oldFileLength) != sourceFile->checksum) {
|
|
Mem_Free(buffer);
|
|
common->Warning("The file %s has been modified outside of the engine.", GetFileName());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// insert new text
|
|
char* declText = (char*)_alloca(textLength + 1);
|
|
GetText(declText);
|
|
memmove(buffer + sourceTextOffset + textLength, buffer + sourceTextOffset + sourceTextLength, oldFileLength - sourceTextOffset - sourceTextLength);
|
|
memcpy(buffer + sourceTextOffset, declText, textLength);
|
|
|
|
// write out new file
|
|
file = fileSystem->OpenFileWrite(GetFileName(), "fs_devpath");
|
|
if (!file) {
|
|
Mem_Free(buffer);
|
|
common->Warning("Couldn't open %s for writing.", GetFileName());
|
|
return false;
|
|
}
|
|
file->Write(buffer, newFileLength);
|
|
fileSystem->CloseFile(file);
|
|
|
|
// set new file size, checksum and timestamp
|
|
sourceFile->fileSize = newFileLength;
|
|
sourceFile->checksum = MD5_BlockChecksum(buffer, newFileLength);
|
|
fileSystem->ReadFile(GetFileName(), NULL, &sourceFile->timestamp);
|
|
|
|
// free buffer
|
|
Mem_Free(buffer);
|
|
|
|
// move all decls in the same file
|
|
for (idDeclLocal* decl = sourceFile->decls; decl; decl = decl->nextInFile) {
|
|
if (decl->sourceTextOffset > sourceTextOffset) {
|
|
decl->sourceTextOffset += textLength - sourceTextLength;
|
|
}
|
|
}
|
|
|
|
// set new size of text in source file
|
|
sourceTextLength = textLength;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::SourceFileChanged
|
|
=================
|
|
*/
|
|
bool idDeclLocal::SourceFileChanged(void) const {
|
|
int newLength;
|
|
ID_TIME_T newTimestamp;
|
|
|
|
if (sourceFile->fileSize <= 0) {
|
|
return false;
|
|
}
|
|
|
|
newLength = fileSystem->ReadFile(GetFileName(), NULL, &newTimestamp);
|
|
|
|
if (newLength != sourceFile->fileSize || newTimestamp != sourceFile->timestamp) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::MakeDefault
|
|
=================
|
|
*/
|
|
void idDeclLocal::MakeDefault() {
|
|
static int recursionLevel;
|
|
const char* defaultText;
|
|
|
|
declManagerLocal.MediaPrint("DEFAULTED\n");
|
|
declState = DS_DEFAULTED;
|
|
|
|
AllocateSelf();
|
|
|
|
defaultText = self->DefaultDefinition();
|
|
|
|
// a parse error inside a DefaultDefinition() string could
|
|
// cause an infinite loop, but normal default definitions could
|
|
// still reference other default definitions, so we can't
|
|
// just dump out on the first recursion
|
|
if (++recursionLevel > 100) {
|
|
common->FatalError("idDecl::MakeDefault: bad DefaultDefinition(): %s", defaultText);
|
|
}
|
|
|
|
// always free data before parsing
|
|
self->FreeData();
|
|
|
|
// parse
|
|
self->Parse(defaultText, strlen(defaultText));
|
|
|
|
// we could still eventually hit the recursion if we have enough Error() calls inside Parse...
|
|
--recursionLevel;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::SetDefaultText
|
|
=================
|
|
*/
|
|
bool idDeclLocal::SetDefaultText(void) {
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::DefaultDefinition
|
|
=================
|
|
*/
|
|
const char* idDeclLocal::DefaultDefinition() const {
|
|
return "{ }";
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Parse
|
|
=================
|
|
*/
|
|
bool idDeclLocal::Parse(const char* text, const int textLength) {
|
|
idLexer src;
|
|
|
|
src.LoadMemory(text, textLength, GetFileName(), GetLineNum());
|
|
src.SetFlags(DECL_LEXER_FLAGS);
|
|
src.SkipUntilString("{");
|
|
src.SkipBracedSection(false);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::FreeData
|
|
=================
|
|
*/
|
|
void idDeclLocal::FreeData() {
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::List
|
|
=================
|
|
*/
|
|
void idDeclLocal::List() const {
|
|
common->Printf("%s\n", GetName());
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Print
|
|
=================
|
|
*/
|
|
void idDeclLocal::Print() const {
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Reload
|
|
=================
|
|
*/
|
|
void idDeclLocal::Reload(void) {
|
|
this->sourceFile->Reload(false);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::AllocateSelf
|
|
=================
|
|
*/
|
|
void idDeclLocal::AllocateSelf(void) {
|
|
if (self == NULL) {
|
|
self = declManagerLocal.GetDeclType((int)type)->allocator();
|
|
self->base = this;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::ParseLocal
|
|
=================
|
|
*/
|
|
void idDeclLocal::ParseLocal(void) {
|
|
bool generatedDefaultText = false;
|
|
|
|
AllocateSelf();
|
|
|
|
// always free data before parsing
|
|
self->FreeData();
|
|
|
|
declManagerLocal.MediaPrint("parsing %s %s\n", declManagerLocal.declTypes[type]->typeName.c_str(), name.c_str());
|
|
|
|
// if no text source try to generate default text
|
|
if (textSource == NULL) {
|
|
generatedDefaultText = self->SetDefaultText();
|
|
}
|
|
|
|
// indent for DEFAULTED or media file references
|
|
declManagerLocal.indent++;
|
|
|
|
// no text immediately causes a MakeDefault()
|
|
if (textSource == NULL) {
|
|
MakeDefault();
|
|
declManagerLocal.indent--;
|
|
return;
|
|
}
|
|
|
|
declState = DS_PARSED;
|
|
|
|
// parse
|
|
char* declText = (char*)_alloca((GetTextLength() + 1) * sizeof(char));
|
|
GetText(declText);
|
|
self->Parse(declText, GetTextLength());
|
|
|
|
// free generated text
|
|
if (generatedDefaultText) {
|
|
Mem_Free(textSource);
|
|
textSource = 0;
|
|
textLength = 0;
|
|
}
|
|
|
|
declManagerLocal.indent--;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::Purge
|
|
=================
|
|
*/
|
|
void idDeclLocal::Purge(void) {
|
|
// never purge things that were referenced outside level load,
|
|
// like the console and menu graphics
|
|
if (parsedOutsideLevelLoad) {
|
|
return;
|
|
}
|
|
|
|
referencedThisLevel = false;
|
|
MakeDefault();
|
|
|
|
// the next Find() for this will re-parse the real data
|
|
declState = DS_UNPARSED;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
idDeclLocal::EverReferenced
|
|
=================
|
|
*/
|
|
bool idDeclLocal::EverReferenced(void) const {
|
|
return everReferenced;
|
|
}
|
|
|
|
const idDeclTable* idDeclManagerLocal::FindTable(const char* name, bool makeDefault) {
|
|
return (const idDeclTable*)FindType(DECL_TABLE, name, makeDefault);
|
|
}
|
|
|
|
#ifdef QUAKE4
|
|
|
|
const rvDeclMatType* idDeclManagerLocal::FindMaterialType(const char* name, bool makeDefault) {
|
|
return (const rvDeclMatType*)FindType(DECL_MATERIALTYPE, name, makeDefault);
|
|
}
|
|
|
|
const rvDeclLipSync* idDeclManagerLocal::FindLipSync(const char* name, bool makeDefault) {
|
|
return (const rvDeclLipSync*)FindType(DECL_LIPSYNC, name, makeDefault);
|
|
}
|
|
|
|
const rvDeclPlayback* idDeclManagerLocal::FindPlayback(const char* name, bool makeDefault) {
|
|
return (const rvDeclPlayback*)FindType(DECL_PLAYBACK, name, makeDefault);
|
|
}
|
|
|
|
const rvDeclEffect* idDeclManagerLocal::FindEffect(const char* name, bool makeDefault) {
|
|
return (const rvDeclEffect*)FindType(DECL_EFFECT, name, makeDefault);
|
|
}
|
|
|
|
const rvDeclMatType* idDeclManagerLocal::MaterialTypeByIndex(int index, bool forceParse) {
|
|
return (const rvDeclMatType*)DeclByIndex(DECL_MATERIALTYPE, index, forceParse);
|
|
}
|
|
|
|
const rvDeclLipSync* idDeclManagerLocal::LipSyncByIndex(int index, bool forceParse) {
|
|
return (const rvDeclLipSync*)DeclByIndex(DECL_LIPSYNC, index, forceParse);
|
|
}
|
|
|
|
const rvDeclPlayback* idDeclManagerLocal::PlaybackByIndex(int index, bool forceParse) {
|
|
return (const rvDeclPlayback*)DeclByIndex(DECL_PLAYBACK, index, forceParse);
|
|
}
|
|
|
|
const rvDeclEffect* idDeclManagerLocal::EffectByIndex(int index, bool forceParse) {
|
|
return (const rvDeclEffect*)DeclByIndex(DECL_EFFECT, index, forceParse);
|
|
}
|
|
|
|
#endif |