id-software/DoomRTX
1
0
Fork 0
mirror of https://github.com/jmarshall23/DoomRTX.git synced 2026-08-12 16:21:04 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
7b232d0011915e35f30c28d79fe2e781dac54501
DoomRTX/neo/engine/framework/DeclManager.cpp
T
Justin Marshall b6ea2fb5fa Added multiplayer page. 
Fixed numerous bugs with the alpha.
2026-05-20 12:44:52 -07:00

3160 lines
85 KiB
C++
Raw Blame History

/*
===========================================================================
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);
// Replaces this decl's range in the backing source file with arbitrary text.
bool WriteSourceFileText(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 bool CreateDeclFile(const char* fileName, declType_t defaultType);
virtual idDecl* CreateNewDecl(declType_t type, const char* name, const char* fileName, bool save = true);
virtual bool SetDeclText(declType_t type, const char* name, const char* text, bool parse = true, bool save = false);
virtual bool SaveDecl(declType_t type, const char* name);
virtual bool DeleteDecl(declType_t type, const char* name, bool deleteSourceText = true);
//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);
int GetDeclFilePriority(const idDeclFile* declFile) const;
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:
idDeclFile* FindDeclFile(const char* fileName) const;
idDeclFile* GetOrCreateDeclFile(const char* fileName, declType_t defaultType, bool createOnDisk);
declType_t GetDefaultTypeForFileName(const char* fileName, declType_t fallback) const;
void RemoveDeclFromSourceFile(idDeclLocal* decl);
void FreeDeclLocal(idDeclLocal* decl);
static void ListDecls_f(const idCmdArgs& args);
static void ReloadDecls_f(const idCmdArgs& args);
static void TouchDecl_f(const idCmdArgs& args);
static void CreateDeclFile_f(const idCmdArgs& args);
static void CreateDecl_f(const idCmdArgs& args);
static void SaveDecl_f(const idCmdArgs& args);
static void DeleteDecl_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, &timestamp);
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;
if ( token.Icmp( "clampTable" ) == 0 || token.Icmp( "snapTable" ) == 0 || token.Icmp( "soundtable" ) == 0 ) {
identifiedType = DECL_TABLE;
}
// get the decl type from the type name
numTypes = declManagerLocal.GetNumDeclTypes();
if ( identifiedType == DECL_MAX_TYPES ) {
for (i = 0; i < numTypes; i++) {
idDeclType* typeInfo = declManagerLocal.GetDeclType(i);
if (typeInfo && typeInfo->typeName.Icmp(token) == 0) {
identifiedType = (declType_t)typeInfo->type;
break;
}
}
}
else {
i = 0;
}
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->sourceFile != this) {
if (declManagerLocal.GetDeclFilePriority(this) < declManagerLocal.GetDeclFilePriority(newDecl->sourceFile)) {
src.Warning("%s '%s' previously defined at %s:%i", declManagerLocal.GetDeclNameFromType(identifiedType),
name.c_str(), newDecl->sourceFile->fileName.c_str(), newDecl->sourceLine);
continue;
}
idDeclLocal** prev = &newDecl->sourceFile->decls;
while (*prev) {
if (*prev == newDecl) {
*prev = newDecl->nextInFile;
break;
}
prev = &(*prev)->nextInFile;
}
newDecl->nextInFile = this->decls;
this->decls = newDecl;
}
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 };
/*
===================
DeclCountLineBreaks
===================
*/
static int DeclCountLineBreaks(const char* text, const int length) {
int count = 0;
if (text == NULL || length <= 0) {
return 0;
}
for (int i = 0; i < length; i++) {
if (text[i] == '\n') {
count++;
}
}
return count;
}
/*
===================
DeclCountFileLines
===================
*/
static int DeclCountFileLines(const char* text, const int length) {
if (text == NULL || length <= 0) {
return 0;
}
return DeclCountLineBreaks(text, length) + 1;
}
/*
===================
DeclLineForOffset
===================
*/
static int DeclLineForOffset(const char* text, const int offset) {
if (text == NULL || offset <= 0) {
return 1;
}
return DeclCountLineBreaks(text, offset) + 1;
}
/*
===================
DeclGetTypeFromCommandArg
===================
*/
static bool DeclGetTypeFromCommandArg(const idCmdArgs& args, const int arg, declType_t& type) {
type = declManagerLocal.GetDeclTypeFromName(args.Argv(arg));
if (type != DECL_MAX_TYPES) {
return true;
}
common->Printf("unknown decl type '%s'\n", args.Argv(arg));
common->Printf("valid types: ");
for (int i = 0; i < declManagerLocal.GetNumDeclTypes(); i++) {
idDeclType* declType = declManagerLocal.GetDeclType(i);
if (declType != NULL) {
common->Printf("%s ", declType->typeName.c_str());
}
}
common->Printf("\n");
return false;
}
/*
===================
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("createDeclFile", CreateDeclFile_f, CMD_FL_SYSTEM, "creates an empty decl file: createDeclFile <type> <file>");
cmdSystem->AddCommand("createDecl", CreateDecl_f, CMD_FL_SYSTEM, "creates and saves a default decl: createDecl <type> <name> <file>");
cmdSystem->AddCommand("saveDecl", SaveDecl_f, CMD_FL_SYSTEM, "saves a decl: saveDecl <type> <name>");
cmdSystem->AddCommand("deleteDecl", DeleteDecl_f, CMD_FL_SYSTEM, "deletes a decl and removes its source text: deleteDecl <type> <name>");
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
===================
*/
void idDeclManagerLocal::RegisterDeclSubFolder(const char* folder, const char* extension, idList<idStr>& fileList) {
idFileList* list = fileSystem->ListFilesTree(folder, extension, false);
for (int i = 0; i < list->GetNumFiles(); i++) {
fileList.Append(list->GetFile(i));
}
fileSystem->FreeFileList(list);
}
/*
===================
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 = fileList.Num() - 1; i >= 0; 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::GetDeclFilePriority
===================
*/
int idDeclManagerLocal::GetDeclFilePriority(const idDeclFile* declFile) const {
if (declFile == &implicitDecls) {
return -1;
}
for (int i = 0; i < loadedFiles.Num(); i++) {
if (loadedFiles[i] == declFile) {
return i;
}
}
return -1;
}
/*
===================
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::GetDefaultTypeForFileName
===================
*/
declType_t idDeclManagerLocal::GetDefaultTypeForFileName(const char* fileName, declType_t fallback) const {
if (fallback != DECL_MAX_TYPES || fileName == NULL || fileName[0] == '\0') {
return fallback;
}
const char* extension = strrchr(fileName, '.');
if (extension == NULL) {
return fallback;
}
for (int i = 0; i < declFolders.Num(); i++) {
if (declFolders[i] != NULL && declFolders[i]->extension.Icmp(extension) == 0) {
return declFolders[i]->defaultType;
}
}
return fallback;
}
/*
===================
idDeclManagerLocal::FindDeclFile
===================
*/
idDeclFile* idDeclManagerLocal::FindDeclFile(const char* _fileName) const {
if (_fileName == NULL || _fileName[0] == '\0') {
return NULL;
}
idStr fileName = _fileName;
fileName.BackSlashesToSlashes();
for (int i = 0; i < loadedFiles.Num(); i++) {
if (loadedFiles[i]->fileName.Icmp(fileName) == 0) {
return loadedFiles[i];
}
}
return NULL;
}
/*
===================
idDeclManagerLocal::GetOrCreateDeclFile
If the file already exists on disk but has not been registered yet, it is
registered and parsed. If it does not exist and createOnDisk is true, an
empty file is written to fs_devpath and registered.
===================
*/
idDeclFile* idDeclManagerLocal::GetOrCreateDeclFile(const char* _fileName, declType_t defaultType, bool createOnDisk) {
if (_fileName == NULL || _fileName[0] == '\0') {
common->Warning("idDeclManager::GetOrCreateDeclFile: empty file name");
return NULL;
}
idStr fileName = _fileName;
fileName.BackSlashesToSlashes();
idDeclFile* sourceFile = FindDeclFile(fileName.c_str());
if (sourceFile != NULL) {
return sourceFile;
}
defaultType = GetDefaultTypeForFileName(fileName.c_str(), defaultType);
ID_TIME_T timestamp = 0;
int length = fileSystem->ReadFile(fileName.c_str(), NULL, &timestamp);
sourceFile = new idDeclFile(fileName.c_str(), defaultType);
loadedFiles.Append(sourceFile);
if (length > 0) {
sourceFile->LoadAndParse();
return sourceFile;
}
if (length == 0) {
sourceFile->timestamp = timestamp;
sourceFile->checksum = MD5_BlockChecksum("", 0);
sourceFile->fileSize = 0;
sourceFile->numLines = 0;
sourceFile->decls = NULL;
return sourceFile;
}
if (!createOnDisk) {
return sourceFile;
}
idFile* file = fileSystem->OpenFileWrite(fileName.c_str(), "fs_devpath");
if (file == NULL) {
loadedFiles.RemoveIndex(loadedFiles.Num() - 1);
delete sourceFile;
common->Warning("Couldn't create decl file %s", fileName.c_str());
return NULL;
}
fileSystem->CloseFile(file);
sourceFile->timestamp = 0;
sourceFile->checksum = MD5_BlockChecksum("", 0);
sourceFile->fileSize = 0;
sourceFile->numLines = 0;
sourceFile->decls = NULL;
fileSystem->ReadFile(fileName.c_str(), NULL, &sourceFile->timestamp);
return sourceFile;
}
/*
===================
idDeclManagerLocal::CreateDeclFile
===================
*/
bool idDeclManagerLocal::CreateDeclFile(const char* fileName, declType_t defaultType) {
int typeIndex = (int)defaultType;
if (defaultType != DECL_MAX_TYPES && (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL)) {
common->Warning("idDeclManager::CreateDeclFile: bad default type: %i", typeIndex);
return false;
}
return GetOrCreateDeclFile(fileName, defaultType, true) != NULL;
}
/*
===================
idDeclManagerLocal::CreateNewDecl
===================
*/
idDecl* idDeclManagerLocal::CreateNewDecl(declType_t type, const char* name, const char* _fileName, bool save) {
int typeIndex = (int)type;
int i, hash;
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
common->FatalError("idDeclManager::CreateNewDecl: bad type: %i", typeIndex);
}
if (name == NULL || name[0] == '\0') {
common->Warning("idDeclManager::CreateNewDecl: empty %s name", declTypes[typeIndex]->typeName.c_str());
return NULL;
}
idDeclFile* sourceFile = GetOrCreateDeclFile(_fileName, type, save);
if (sourceFile == NULL) {
return NULL;
}
char canonicalName[MAX_STRING_CHARS];
MakeNameCanonical(name, canonicalName, sizeof(canonicalName));
idDeclLocal* decl = NULL;
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) {
decl = linearLists[typeIndex][i];
break;
}
}
// If an explicit decl already exists, keep the invariant that type/name is unique.
if (decl != NULL && decl->sourceFile != &implicitDecls) {
decl->AllocateSelf();
common->Warning("%s '%s' already exists at %s:%i", declTypes[typeIndex]->typeName.c_str(),
canonicalName, decl->sourceFile->fileName.c_str(), decl->sourceLine);
return decl->self;
}
bool createdNewDecl = false;
if (decl == NULL) {
decl = new idDeclLocal;
decl->self = NULL;
decl->name = canonicalName;
decl->type = type;
decl->declState = DS_UNPARSED;
decl->referencedThisLevel = false;
decl->everReferenced = false;
decl->parsedOutsideLevelLoad = !insideLevelLoad;
createdNewDecl = true;
}
decl->AllocateSelf();
idStr declText;
if (sourceFile->fileSize > 0) {
declText = "\n\n";
}
declText += declTypes[typeIndex]->typeName;
declText += " ";
declText += canonicalName;
declText += " ";
declText += decl->self->DefaultDefinition();
if (declText.Length() <= 0 || declText[declText.Length() - 1] != '\n') {
declText += "\n";
}
decl->SetTextLocal(declText.c_str(), declText.Length());
decl->sourceFile = sourceFile;
decl->sourceTextOffset = sourceFile->fileSize;
decl->sourceTextLength = 0;
decl->sourceLine = (sourceFile->numLines > 0) ? sourceFile->numLines : 1;
decl->declState = DS_UNPARSED;
// add this decl to the source file list
decl->nextInFile = sourceFile->decls;
sourceFile->decls = decl;
// add new explicit decls to the hash table and linear list
if (createdNewDecl) {
decl->index = linearLists[typeIndex].Num();
hashTables[typeIndex].Add(hash, linearLists[typeIndex].Append(decl));
}
decl->ParseLocal();
if (save && !decl->ReplaceSourceFileText()) {
common->Warning("%s '%s' was created in memory but could not be saved to %s",
declTypes[typeIndex]->typeName.c_str(), canonicalName, sourceFile->fileName.c_str());
}
return decl->self;
}
/*
===================
idDeclManagerLocal::SetDeclText
===================
*/
bool idDeclManagerLocal::SetDeclText(declType_t type, const char* name, const char* text, bool parse, bool save) {
int typeIndex = (int)type;
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
common->FatalError("idDeclManager::SetDeclText: bad type: %i", typeIndex);
}
if (text == NULL) {
common->Warning("idDeclManager::SetDeclText: NULL text for %s '%s'", declTypes[typeIndex]->typeName.c_str(), name ? name : "<NULL>");
return false;
}
idDeclLocal* decl = FindTypeWithoutParsing(type, name, false);
if (decl == NULL) {
common->Warning("idDeclManager::SetDeclText: %s '%s' not found", declTypes[typeIndex]->typeName.c_str(), name ? name : "<NULL>");
return false;
}
decl->SetTextLocal(text, idStr::Length(text));
decl->declState = DS_UNPARSED;
if (parse) {
decl->ParseLocal();
}
if (save) {
return decl->ReplaceSourceFileText();
}
return true;
}
/*
===================
idDeclManagerLocal::SaveDecl
===================
*/
bool idDeclManagerLocal::SaveDecl(declType_t type, const char* name) {
int typeIndex = (int)type;
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
common->FatalError("idDeclManager::SaveDecl: bad type: %i", typeIndex);
}
idDeclLocal* decl = FindTypeWithoutParsing(type, name, false);
if (decl == NULL) {
common->Warning("idDeclManager::SaveDecl: %s '%s' not found", declTypes[typeIndex]->typeName.c_str(), name ? name : "<NULL>");
return false;
}
if (decl->textSource == NULL) {
common->Warning("idDeclManager::SaveDecl: %s '%s' has no source text", declTypes[typeIndex]->typeName.c_str(), decl->GetName());
return false;
}
return decl->ReplaceSourceFileText();
}
/*
===================
idDeclManagerLocal::RemoveDeclFromSourceFile
===================
*/
void idDeclManagerLocal::RemoveDeclFromSourceFile(idDeclLocal* decl) {
if (decl == NULL || decl->sourceFile == NULL) {
return;
}
idDeclLocal** prev = &decl->sourceFile->decls;
while (*prev != NULL) {
if (*prev == decl) {
*prev = decl->nextInFile;
decl->nextInFile = NULL;
return;
}
prev = &(*prev)->nextInFile;
}
}
/*
===================
idDeclManagerLocal::FreeDeclLocal
===================
*/
void idDeclManagerLocal::FreeDeclLocal(idDeclLocal* decl) {
if (decl == NULL) {
return;
}
if (decl->self != NULL) {
decl->self->FreeData();
delete decl->self;
decl->self = NULL;
}
if (decl->textSource != NULL) {
Mem_Free(decl->textSource);
decl->textSource = NULL;
}
delete decl;
}
/*
===================
idDeclManagerLocal::DeleteDecl
===================
*/
bool idDeclManagerLocal::DeleteDecl(declType_t type, const char* name, bool deleteSourceText) {
int typeIndex = (int)type;
if (typeIndex < 0 || typeIndex >= declTypes.Num() || declTypes[typeIndex] == NULL) {
common->FatalError("idDeclManager::DeleteDecl: bad type: %i", typeIndex);
}
idDeclLocal* decl = FindTypeWithoutParsing(type, name, false);
if (decl == NULL) {
common->Warning("idDeclManager::DeleteDecl: %s '%s' not found", declTypes[typeIndex]->typeName.c_str(), name ? name : "<NULL>");
return false;
}
if (deleteSourceText && decl->sourceFile != &implicitDecls) {
if (!decl->WriteSourceFileText("", 0)) {
return false;
}
}
RemoveDeclFromSourceFile(decl);
int oldIndex = decl->index;
int hashKey = hashTables[typeIndex].GenerateKey(decl->name.c_str(), false);
hashTables[typeIndex].RemoveIndex(hashKey, oldIndex);
linearLists[typeIndex].RemoveIndex(oldIndex);
for (int i = oldIndex; i < linearLists[typeIndex].Num(); i++) {
linearLists[typeIndex][i]->index = i;
}
FreeDeclLocal(decl);
return true;
}
/*
===============
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::CreateDeclFile_f
===================
*/
void idDeclManagerLocal::CreateDeclFile_f(const idCmdArgs& args) {
if (args.Argc() != 3) {
common->Printf("usage: createDeclFile <type> <file>\n");
return;
}
declType_t type;
if (!DeclGetTypeFromCommandArg(args, 1, type)) {
return;
}
if (declManagerLocal.CreateDeclFile(args.Argv(2), type)) {
common->Printf("created decl file '%s'\n", args.Argv(2));
}
}
/*
===================
idDeclManagerLocal::CreateDecl_f
===================
*/
void idDeclManagerLocal::CreateDecl_f(const idCmdArgs& args) {
if (args.Argc() != 4) {
common->Printf("usage: createDecl <type> <name> <file>\n");
return;
}
declType_t type;
if (!DeclGetTypeFromCommandArg(args, 1, type)) {
return;
}
idDecl* decl = declManagerLocal.CreateNewDecl(type, args.Argv(2), args.Argv(3), true);
if (decl != NULL) {
common->Printf("created %s '%s' in '%s'\n", declManagerLocal.GetDeclNameFromType(type), decl->GetName(), decl->GetFileName());
}
}
/*
===================
idDeclManagerLocal::SaveDecl_f
===================
*/
void idDeclManagerLocal::SaveDecl_f(const idCmdArgs& args) {
if (args.Argc() != 3) {
common->Printf("usage: saveDecl <type> <name>\n");
return;
}
declType_t type;
if (!DeclGetTypeFromCommandArg(args, 1, type)) {
return;
}
if (declManagerLocal.SaveDecl(type, args.Argv(2))) {
common->Printf("saved %s '%s'\n", declManagerLocal.GetDeclNameFromType(type), args.Argv(2));
}
}
/*
===================
idDeclManagerLocal::DeleteDecl_f
===================
*/
void idDeclManagerLocal::DeleteDecl_f(const idCmdArgs& args) {
if (args.Argc() != 3) {
common->Printf("usage: deleteDecl <type> <name>\n");
return;
}
declType_t type;
if (!DeclGetTypeFromCommandArg(args, 1, type)) {
return;
}
if (declManagerLocal.DeleteDecl(type, args.Argv(2), true)) {
common->Printf("deleted %s '%s'\n", declManagerLocal.GetDeclNameFromType(type), 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) {
self = NULL;
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::WriteSourceFileText
=================
*/
bool idDeclLocal::WriteSourceFileText(const char* replacementText, const int replacementLength) {
int oldFileLength, newFileLength;
char* buffer;
idFile* file;
if (replacementText == NULL || replacementLength < 0) {
common->Warning("idDeclLocal::WriteSourceFileText: bad replacement text for %s", GetName());
return false;
}
if (sourceFile == NULL || sourceFile == &declManagerLocal.implicitDecls) {
common->Warning("Can't save implicit declaration %s.", GetName());
return false;
}
oldFileLength = sourceFile->fileSize;
if (sourceTextOffset < 0 || sourceTextOffset > oldFileLength || sourceTextLength < 0 || sourceTextOffset + sourceTextLength > oldFileLength) {
common->Warning("Decl %s has an invalid source range in %s.", GetName(), GetFileName());
return false;
}
newFileLength = oldFileLength - sourceTextLength + replacementLength;
buffer = (char*)Mem_Alloc(Max(Max(newFileLength, oldFileLength), 1));
// read original file if it is known to exist
if (sourceFile->timestamp != 0 || sourceFile->fileSize > 0) {
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) {
fileSystem->CloseFile(file);
Mem_Free(buffer);
common->Warning("The file %s has been modified outside of the engine.", GetFileName());
return false;
}
if (oldFileLength > 0) {
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;
}
}
int oldLineBreaks = DeclCountLineBreaks(buffer + sourceTextOffset, sourceTextLength);
int newLineBreaks = DeclCountLineBreaks(replacementText, replacementLength);
int textDelta = replacementLength - sourceTextLength;
int lineDelta = newLineBreaks - oldLineBreaks;
// insert replacement text
memmove(buffer + sourceTextOffset + replacementLength,
buffer + sourceTextOffset + sourceTextLength,
oldFileLength - sourceTextOffset - sourceTextLength);
if (replacementLength > 0) {
memcpy(buffer + sourceTextOffset, replacementText, replacementLength);
}
// 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;
}
if (newFileLength > 0) {
file->Write(buffer, newFileLength);
}
fileSystem->CloseFile(file);
// set new file size, checksum, timestamp, and line count
sourceFile->fileSize = newFileLength;
sourceFile->checksum = MD5_BlockChecksum(buffer, newFileLength);
sourceFile->numLines = DeclCountFileLines(buffer, newFileLength);
fileSystem->ReadFile(GetFileName(), NULL, &sourceFile->timestamp);
// move all decls in the same file
for (idDeclLocal* decl = sourceFile->decls; decl; decl = decl->nextInFile) {
if (decl != this && decl->sourceTextOffset > sourceTextOffset) {
decl->sourceTextOffset += textDelta;
decl->sourceLine += lineDelta;
}
}
// set new size of text in source file
sourceTextLength = replacementLength;
sourceLine = DeclLineForOffset(buffer, sourceTextOffset);
Mem_Free(buffer);
return true;
}
/*
=================
idDeclLocal::ReplaceSourceFileText
=================
*/
bool idDeclLocal::ReplaceSourceFileText(void) {
if (textSource == NULL) {
common->Warning("Decl %s has no text to save.", GetName());
return false;
}
common->Printf("Writing \'%s\' to \'%s\'...\n", GetName(), GetFileName());
char* declText = (char*)_alloca(textLength + 1);
GetText(declText);
return WriteSourceFileText(declText, textLength);
}
/*
=================
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
Reference in New Issue View Git Blame Copy Permalink