Main Page | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals
code / bspc

l_qfiles.h File Reference

#include "../qcommon/unzip.h"

Include dependency graph for l_qfiles.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Data Structures

struct  dsinpackfile_t
struct  quakefile_s

Defines

#define _MAX_PATH   1024
#define MAX_PAK_FILENAME_LENGTH   120
#define QFILEEXT_AAS   ".AAS"
#define QFILEEXT_BSP   ".BSP"
#define QFILEEXT_MAP   ".MAP"
#define QFILEEXT_MD2   ".MD2"
#define QFILEEXT_MD3   ".MD3"
#define QFILEEXT_MDL   ".MDL"
#define QFILEEXT_PAK   ".PAK"
#define QFILEEXT_PK3   ".PK3"
#define QFILEEXT_SIN   ".SIN"
#define QFILEEXT_UNKNOWN   ""
#define QFILEEXT_WAL   ".WAL"
#define QFILEEXT_WAV   ".WAV"
#define QFILETYPE_AAS   0x4000
#define QFILETYPE_BSP   0x0004
#define QFILETYPE_MAP   0x0008
#define QFILETYPE_MD2   0x0020
#define QFILETYPE_MD3   0x0040
#define QFILETYPE_MDL   0x0010
#define QFILETYPE_PAK   0x0001
#define QFILETYPE_PK3   0x0002
#define QFILETYPE_UNKNOWN   0x8000
#define QFILETYPE_WAL   0x0080
#define QFILETYPE_WAV   0x0100
#define SINPAKHEADER   (('K'<<24)+('A'<<16)+('P'<<8)+'S')

Typedefs

typedef quakefile_s quakefile_t

Functions

int FileFilter (char *filter, char *filename, int casesensitive)
quakefile_t * FindQuakeFiles (char *filter)
int LoadQuakeFile (quakefile_t *qf, void **bufferptr)
int QuakeFileExtensionType (char *extension)
int QuakeFileType (char *filename)
char * QuakeFileTypeExtension (int type)
int ReadQuakeFile (quakefile_t *qf, void *buffer, int offset, int length)

Define Documentation

#define _MAX_PATH   1024
 

Definition at line 52 of file l_qfiles.h.

Referenced by CheckBspProcess(), CreateAASFilesForAllBSPFiles(), DLLBuildDone(), FindQuakeFilesWithPakFilter(), CRadiantApp::InitInstance(), CMainFrame::OnCreate(), and QE_LoadProject().

#define MAX_PAK_FILENAME_LENGTH   120
 

Definition at line 56 of file l_qfiles.h.

#define QFILEEXT_AAS   ".AAS"
 

Definition at line 48 of file l_qfiles.h.

#define QFILEEXT_BSP   ".BSP"
 

Definition at line 41 of file l_qfiles.h.

#define QFILEEXT_MAP   ".MAP"
 

Definition at line 42 of file l_qfiles.h.

#define QFILEEXT_MD2   ".MD2"
 

Definition at line 44 of file l_qfiles.h.

#define QFILEEXT_MD3   ".MD3"
 

Definition at line 45 of file l_qfiles.h.

#define QFILEEXT_MDL   ".MDL"
 

Definition at line 43 of file l_qfiles.h.

#define QFILEEXT_PAK   ".PAK"
 

Definition at line 38 of file l_qfiles.h.

#define QFILEEXT_PK3   ".PK3"
 

Definition at line 39 of file l_qfiles.h.

#define QFILEEXT_SIN   ".SIN"
 

Definition at line 40 of file l_qfiles.h.

#define QFILEEXT_UNKNOWN   ""
 

Definition at line 37 of file l_qfiles.h.

#define QFILEEXT_WAL   ".WAL"
 

Definition at line 46 of file l_qfiles.h.

#define QFILEEXT_WAV   ".WAV"
 

Definition at line 47 of file l_qfiles.h.

#define QFILETYPE_AAS   0x4000
 

Definition at line 35 of file l_qfiles.h.

#define QFILETYPE_BSP   0x0004
 

Definition at line 28 of file l_qfiles.h.

#define QFILETYPE_MAP   0x0008
 

Definition at line 29 of file l_qfiles.h.

#define QFILETYPE_MD2   0x0020
 

Definition at line 31 of file l_qfiles.h.

#define QFILETYPE_MD3   0x0040
 

Definition at line 32 of file l_qfiles.h.

#define QFILETYPE_MDL   0x0010
 

Definition at line 30 of file l_qfiles.h.

#define QFILETYPE_PAK   0x0001
 

Definition at line 26 of file l_qfiles.h.

#define QFILETYPE_PK3   0x0002
 

Definition at line 27 of file l_qfiles.h.

#define QFILETYPE_UNKNOWN   0x8000
 

Definition at line 25 of file l_qfiles.h.

#define QFILETYPE_WAL   0x0080
 

Definition at line 33 of file l_qfiles.h.

#define QFILETYPE_WAV   0x0100
 

Definition at line 34 of file l_qfiles.h.

#define SINPAKHEADER   (('K'<<24)+('A'<<16)+('P'<<8)+'S')
 

Definition at line 57 of file l_qfiles.h.

Typedef Documentation

typedef struct quakefile_s quakefile_t
 

Referenced by AASOuputFile(), CM_LoadMap(), CreateAASFilesForAllBSPFiles(), FindQuakeFiles(), FindQuakeFilesInPak(), FindQuakeFilesInZip(), FindQuakeFilesWithPakFilter(), GetArgumentFiles(), LoadQuakeFile(), main(), and ReadQuakeFile().

Function Documentation

int FileFilter (  char *  filter,
char *  filename,
int  casesensitive
) 
 

Definition at line 144 of file l_qfiles.c.

References i, ptr(), StringContains(), strlen(), and toupper().

Referenced by FindQuakeFilesInPak(), and FindQuakeFilesInZip().

00145 {
00146     char buf[1024];
00147     char *ptr;
00148     int i, found;
00149 
00150     while(*filter)
00151     {
00152         if (*filter == '*')
00153         {
00154             filter++;
00155             for (i = 0; *filter; i++)
00156             {
00157                 if (*filter == '*' || *filter == '?') break;
00158                 buf[i] = *filter;
00159                 filter++;
00160             } //end for
00161             buf[i] = '\0';
00162             if (strlen(buf))
00163             {
00164                 ptr = StringContains(filename, buf, casesensitive);
00165                 if (!ptr) return false;
00166                 filename = ptr + strlen(buf);
00167             } //end if
00168         } //end if
00169         else if (*filter == '?')
00170         {
00171             filter++;
00172             filename++;
00173         } //end else if
00174         else if (*filter == '[' && *(filter+1) == '[')
00175         {
00176             filter++;
00177         } //end if
00178         else if (*filter == '[')
00179         {
00180             filter++;
00181             found = false;
00182             while(*filter && !found)
00183             {
00184                 if (*filter == ']' && *(filter+1) != ']') break;
00185                 if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']'))
00186                 {
00187                     if (casesensitive)
00188                     {
00189                         if (*filename >= *filter && *filename <= *(filter+2)) found = true;
00190                     } //end if
00191                     else
00192                     {
00193                         if (toupper(*filename) >= toupper(*filter) &&
00194                             toupper(*filename) <= toupper(*(filter+2))) found = true;
00195                     } //end else
00196                     filter += 3;
00197                 } //end if
00198                 else
00199                 {
00200                     if (casesensitive)
00201                     {
00202                         if (*filter == *filename) found = true;
00203                     } //end if
00204                     else
00205                     {
00206                         if (toupper(*filter) == toupper(*filename)) found = true;
00207                     } //end else
00208                     filter++;
00209                 } //end else
00210             } //end while
00211             if (!found) return false;
00212             while(*filter)
00213             {
00214                 if (*filter == ']' && *(filter+1) != ']') break;
00215                 filter++;
00216             } //end while
00217             filter++;
00218             filename++;
00219         } //end else if
00220         else
00221         {
00222             if (casesensitive)
00223             {
00224                 if (*filter != *filename) return false;
00225             } //end if
00226             else
00227             {
00228                 if (toupper(*filter) != toupper(*filename)) return false;
00229             } //end else
00230             filter++;
00231             filename++;
00232         } //end else
00233     } //end while
00234     return true;
00235 } //end of the function FileFilter

Here is the call graph for this function:

quakefile_t* FindQuakeFiles (  char *  filter  ) 
 

Definition at line 539 of file l_qfiles.c.

References ConvertPath(), FindQuakeFilesWithPakFilter(), NULL, quakefile_t, strcpy(), StringContains(), and strlen().

Referenced by CreateAASFilesForAllBSPFiles(), and GetArgumentFiles().

00540 {
00541     char *str;
00542     char newfilter[_MAX_PATH];
00543     char pakfilter[_MAX_PATH];
00544     char filefilter[_MAX_PATH];
00545 
00546     strcpy(newfilter, filter);
00547     ConvertPath(newfilter);
00548     strcpy(pakfilter, newfilter);
00549 
00550     str = StringContains(pakfilter, ".pak", false);
00551     if (!str) str = StringContains(pakfilter, ".pk3", false);
00552 
00553     if (str)
00554     {
00555         str += strlen(".pak");
00556         if (*str)
00557         {
00558             *str++ = '\0';
00559             while(*str == '\\' || *str == '/') str++;
00560             strcpy(filefilter, str);
00561             return FindQuakeFilesWithPakFilter(pakfilter, filefilter);
00562         } //end if
00563     } //end else
00564     return FindQuakeFilesWithPakFilter(NULL, newfilter);
00565 } //end of the function FindQuakeFiles

Here is the call graph for this function:

int LoadQuakeFile (  quakefile_t *  qf,
void **  bufferptr
) 
 

Definition at line 572 of file l_qfiles.c.

References buffer, fclose(), unz_s::file, quakefile_s::filename, fp, fseek(), GetMemory(), quakefile_s::length, length(), quakefile_s::offset, quakefile_s::pakfile, Q_filelength(), quakefile_t, SafeOpenRead(), SafeRead(), SEEK_SET, unzClose(), unzCloseCurrentFile(), unzFile, unzOpen(), unzOpenCurrentFile(), unzReadCurrentFile(), quakefile_s::zipfile, and quakefile_s::zipinfo.

Referenced by CM_LoadMap(), and Q3_LoadBSPFile().

00573 {
00574     FILE *fp;
00575     void *buffer;
00576     int length;
00577     unzFile zf;
00578 
00579     if (qf->zipfile)
00580     {
00581         //open the zip file
00582         zf = unzOpen(qf->pakfile);
00583         //set the file pointer
00584         qf->zipinfo.file = ((unz_s *) zf)->file;
00585         //open the Quake file in the zip file
00586         unzOpenCurrentFile(&qf->zipinfo);
00587         //allocate memory for the buffer
00588         length = qf->length;
00589         buffer = GetMemory(length+1);
00590         //read the Quake file from the zip file
00591         length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
00592         //close the Quake file in the zip file
00593         unzCloseCurrentFile(&qf->zipinfo);
00594         //close the zip file
00595         unzClose(zf);
00596 
00597         *bufferptr = buffer;
00598         return length;
00599     } //end if
00600     else
00601     {
00602         fp = SafeOpenRead(qf->filename);
00603         if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
00604         length = qf->length;
00605         if (!length) length = Q_filelength(fp);
00606         buffer = GetMemory(length+1);
00607         ((char *)buffer)[length] = 0;
00608         SafeRead(fp, buffer, length);
00609         fclose(fp);
00610 
00611         *bufferptr = buffer;
00612         return length;
00613     } //end else
00614 } //end of the function LoadQuakeFile

Here is the call graph for this function:

int QuakeFileExtensionType (  char *  extension  ) 
 

Definition at line 65 of file l_qfiles.c.

References qfile_exttype_s::extension, i, quakefiletypes, and qfile_exttype_s::type.

Referenced by QuakeFileType().

00066 {
00067     int i;
00068 
00069     for (i = 0; quakefiletypes[i].extension; i++)
00070     {
00071         if (!stricmp(extension, quakefiletypes[i].extension))
00072         {
00073             return quakefiletypes[i].type;
00074         } //end if
00075     } //end for
00076     return QFILETYPE_UNKNOWN;
00077 } //end of the function QuakeFileExtensionType

int QuakeFileType (  char *  filename  ) 
 

Definition at line 103 of file l_qfiles.c.

References ExtractFileExtension(), and QuakeFileExtensionType().

Referenced by FindQuakeFilesInPak(), FindQuakeFilesInZip(), and FindQuakeFilesWithPakFilter().

00104 {
00105     char ext[_MAX_PATH] = ".";
00106 
00107     ExtractFileExtension(filename, ext+1);
00108     return QuakeFileExtensionType(ext);
00109 } //end of the function QuakeFileTypeFromFileName

Here is the call graph for this function:

char* QuakeFileTypeExtension (  int  type  ) 
 

Definition at line 84 of file l_qfiles.c.

References qfile_exttype_s::extension, i, quakefiletypes, and qfile_exttype_s::type.

00085 {
00086     int i;
00087 
00088     for (i = 0; quakefiletypes[i].extension; i++)
00089     {
00090         if (quakefiletypes[i].type == type)
00091         {
00092             return quakefiletypes[i].extension;
00093         } //end if
00094     } //end for
00095     return QFILEEXT_UNKNOWN;
00096 } //end of the function QuakeFileExtension

int ReadQuakeFile (  quakefile_t *  qf,
void *  buffer,
int  offset,
int  length
) 
 

Definition at line 621 of file l_qfiles.c.

References buffer, fclose(), unz_s::file, quakefile_s::filename, fp, fseek(), length(), quakefile_s::offset, offset, quakefile_s::pakfile, quakefile_t, read(), SafeOpenRead(), SafeRead(), SEEK_CUR, SEEK_SET, unzClose(), unzCloseCurrentFile(), unzFile, unzOpen(), unzOpenCurrentFile(), unzReadCurrentFile(), quakefile_s::zipfile, and quakefile_s::zipinfo.

Referenced by LoadMapFromBSP().

00622 {
00623     FILE *fp;
00624     int read;
00625     unzFile zf;
00626     char tmpbuf[1024];
00627 
00628     if (qf->zipfile)
00629     {
00630         //open the zip file
00631         zf = unzOpen(qf->pakfile);
00632         //set the file pointer
00633         qf->zipinfo.file = ((unz_s *) zf)->file;
00634         //open the Quake file in the zip file
00635         unzOpenCurrentFile(&qf->zipinfo);
00636         //
00637         while(offset > 0)
00638         {
00639             read = offset;
00640             if (read > sizeof(tmpbuf)) read = sizeof(tmpbuf);
00641             unzReadCurrentFile(&qf->zipinfo, tmpbuf, read);
00642             offset -= read;
00643         } //end while
00644         //read the Quake file from the zip file
00645         length = unzReadCurrentFile(&qf->zipinfo, buffer, length);
00646         //close the Quake file in the zip file
00647         unzCloseCurrentFile(&qf->zipinfo);
00648         //close the zip file
00649         unzClose(zf);
00650 
00651         return length;
00652     } //end if
00653     else
00654     {
00655         fp = SafeOpenRead(qf->filename);
00656         if (qf->offset) fseek(fp, qf->offset, SEEK_SET);
00657         if (offset) fseek(fp, offset, SEEK_CUR);
00658         SafeRead(fp, buffer, length);
00659         fclose(fp);
00660 
00661         return length;
00662     } //end else
00663 } //end of the function ReadQuakeFile

Here is the call graph for this function:

Generated on Thu Aug 25 12:54:41 2005 for Quake III Arena by  doxygen 1.3.9.1