files.c File Reference

#include "qcommon.h"

Go to the source code of this file.

Classes
struct	packfile_t
struct	pack_s
struct	filelink_s
struct	searchpath_s

Macros
#define	PAK0_CHECKSUM   0x40e614e0
#define	MAX_READ   0x10000

Typedefs
typedef struct pack_s	pack_t
typedef struct filelink_s	filelink_t
typedef struct searchpath_s	searchpath_t

Functions
int	FS_filelength (FILE *f)
void	FS_CreatePath (char *path)
void	FS_FCloseFile (FILE *f)
int	Developer_searchpath (int who)
int	FS_FOpenFile (char *filename, FILE **file)
void	CDAudio_Stop (void)
void	FS_Read (void *buffer, int len, FILE *f)
int	FS_LoadFile (char *path, void **buffer)
void	FS_FreeFile (void *buffer)
pack_t *	FS_LoadPackFile (char *packfile)
void	FS_AddGameDirectory (char *dir)
void	FS_AddHomeAsGameDirectory (char *dir)
char *	FS_Gamedir (void)
void	FS_ExecAutoexec (void)
void	FS_SetGamedir (char *dir)
void	FS_Link_f (void)
char **	FS_ListFiles (char *findname, int *numfiles, unsigned musthave, unsigned canthave)
void	FS_Dir_f (void)
void	FS_Path_f (void)
char *	FS_NextPath (char *prevpath)
void	FS_InitFilesystem (void)

Variables
char	fs_gamedir [MAX_OSPATH]
cvar_t *	fs_basedir
cvar_t *	fs_cddir
cvar_t *	fs_gamedirvar
filelink_t *	fs_links
searchpath_t *	fs_searchpaths
searchpath_t *	fs_base_searchpaths
int	file_from_pak = 0

Macro Definition Documentation

MAX_READ

#define MAX_READ   0x10000

Definition at line 345 of file files.c.

PAK0_CHECKSUM

#define PAK0_CHECKSUM   0x40e614e0

Definition at line 28 of file files.c.

Typedef Documentation

filelink_t

typedef struct filelink_s filelink_t

pack_t

typedef struct pack_s pack_t

searchpath_t

typedef struct searchpath_s searchpath_t

Function Documentation

CDAudio_Stop()

void CDAudio_Stop

(

void

)

Referenced by CDAudio_Play2(), CDAudio_RandomPlay(), FS_Read(), SCR_BeginLoadingPlaque(), SCR_PlayCinematic(), and UpdateCDVolumeFunc().

Developer_searchpath()

int Developer_searchpath

(

int

who

)

Definition at line 159 of file files.c.

{
    
    int     ch;
    // PMM - warning removal
//  char    *start;
    searchpath_t    *search;
    
    if (who == 1) // xatrix
        ch = 'x';
    else if (who == 2)
        ch = 'r';
 
    for (search = fs_searchpaths ; search ; search = search->next)
    {
        if (strstr (search->filename, "xatrix"))
            return 1;
 
        if (strstr (search->filename, "rogue"))
            return 2;
/*
        start = strchr (search->filename, ch);
 
        if (start == NULL)
            continue;
 
        if (strcmp (start ,"xatrix") == 0)
            return (1);
*/
    }
    return (0);
 
}

Referenced by CL_AddPacketEntities(), DMFlagCallback(), DMOptions_MenuInit(), M_Menu_Credits_f(), RulesChangeFunc(), StartServer_MenuInit(), and StartServerActionFunc().

FS_AddGameDirectory()

void FS_AddGameDirectory

(

char *

dir

)

Definition at line 513 of file files.c.

{
    int             i;
    searchpath_t    *search;
    pack_t          *pak;
    char            pakfile[MAX_OSPATH];
 
    //
    // add the base directory to the search path
    //
    search = Z_Malloc (sizeof(searchpath_t));
    strncpy (search->filename, dir, sizeof(search->filename)-1);
    search->filename[sizeof(search->filename)-1] = 0;
    
    search->next = fs_searchpaths;
    fs_searchpaths = search;
 
    //
    // add any pak files in the format pak0.pak pak1.pak, ...
    //
    for (i=0; i<50; i++)
    {
      Com_sprintf (pakfile, sizeof(pakfile), "%s/pak%i.pak", dir, i);
      pak = FS_LoadPackFile (pakfile);
      if (!pak)
        continue;
      search = Z_Malloc (sizeof(searchpath_t));
      search->pack = pak;
      search->next = fs_searchpaths;
      fs_searchpaths = search;      
    }
#ifdef QMAX
    Com_sprintf (pakfile, sizeof(pakfile), "%s/maxpak.pak", dir);
    pak = FS_LoadPackFile (pakfile);
    search = Z_Malloc (sizeof(searchpath_t));
    search->pack = pak;
    search->next = fs_searchpaths;
    fs_searchpaths = search;
#endif
}

Referenced by FS_AddHomeAsGameDirectory(), FS_InitFilesystem(), and FS_SetGamedir().

FS_AddHomeAsGameDirectory()

void FS_AddHomeAsGameDirectory

(

char *

dir

)

Definition at line 561 of file files.c.

{
#ifndef _WIN32
    char gdir[MAX_OSPATH];
    char *homedir=getenv("HOME");
    if(homedir)
    {
        int len = snprintf(gdir,sizeof(gdir),"%s/.quake2/%s/", homedir, dir);
        Com_Printf("using %s for writing\n",gdir);
        FS_CreatePath (gdir);
 
        if ((len > 0) && (len < sizeof(gdir)) && (gdir[len-1] == '/'))
            gdir[len-1] = 0;
 
        strncpy(fs_gamedir,gdir,sizeof(fs_gamedir)-1);
        fs_gamedir[sizeof(fs_gamedir)-1] = 0;
        
        FS_AddGameDirectory (gdir);
    }
#endif
}

Referenced by FS_InitFilesystem(), and FS_SetGamedir().

FS_CreatePath()

void FS_CreatePath

(

char *

path

)

Definition at line 125 of file files.c.

{
    char    *ofs;
    
    for (ofs = path+1 ; *ofs ; ofs++)
    {
        if (*ofs == '/')
        {   // create the directory
            *ofs = 0;
            Sys_Mkdir (path);
            *ofs = '/';
        }
    }
}

Referenced by CL_ParseDownload(), CL_Record_f(), Con_Dump_f(), FS_AddHomeAsGameDirectory(), SV_CopySaveGame(), SV_GameMap_f(), and SV_ServerRecord_f().

FS_Dir_f()

void FS_Dir_f

(

void

)

Definition at line 784 of file files.c.

{
    char    *path = NULL;
    char    findname[1024];
    char    wildcard[1024] = "*.*";
    char    **dirnames;
    int     ndirs;
 
    if ( Cmd_Argc() != 1 )
    {
        strcpy( wildcard, Cmd_Argv( 1 ) );
    }
 
    while ( ( path = FS_NextPath( path ) ) != NULL )
    {
        char *tmp = findname;
 
        Com_sprintf( findname, sizeof(findname), "%s/%s", path, wildcard );
 
        while ( *tmp != 0 )
        {
            if ( *tmp == '\\' ) 
                *tmp = '/';
            tmp++;
        }
        Com_Printf( "Directory of %s\n", findname );
        Com_Printf( "----\n" );
 
        if ( ( dirnames = FS_ListFiles( findname, &ndirs, 0, 0 ) ) != 0 )
        {
            int i;
 
            for ( i = 0; i < ndirs-1; i++ )
            {
                if ( strrchr( dirnames[i], '/' ) )
                    Com_Printf( "%s\n", strrchr( dirnames[i], '/' ) + 1 );
                else
                    Com_Printf( "%s\n", dirnames[i] );
 
                free( dirnames[i] );
            }
            free( dirnames );
        }
        Com_Printf( "\n" );
    };
}

Referenced by FS_InitFilesystem().

FS_ExecAutoexec()

void FS_ExecAutoexec

(

void

)

Definition at line 600 of file files.c.

{
    char name [MAX_QPATH];
    searchpath_t *s, *end;
 
    // don't look in baseq2 if gamedir is set
    if (fs_searchpaths == fs_base_searchpaths)
        end = NULL;
    else
        end = fs_base_searchpaths;
    
    // search through all the paths for an autoexec.cfg file    
    for (s = fs_searchpaths ; s != end ; s = s->next)
    {
        if (s->pack)
            continue;
 
        Com_sprintf(name, sizeof(name), "%s/autoexec.cfg", s->filename); 
 
        if (Sys_FindFirst(name, 0, SFF_SUBDIR | SFF_HIDDEN | SFF_SYSTEM))
        {
            Cbuf_AddText ("exec autoexec.cfg\n");
            Sys_FindClose();
            break;
        }
        Sys_FindClose();
    }
}

Referenced by CL_Init(), Cvar_GetLatchedVars(), and Cvar_Set2().

FS_FCloseFile()

void FS_FCloseFile

(

FILE *

f

)

Definition at line 149 of file files.c.

{
    fclose (f);
}

Referenced by S_RegisterSexedSound().

FS_filelength()

int FS_filelength

(

FILE *

f

)

Definition at line 104 of file files.c.

{
    int     pos;
    int     end;
 
    pos = ftell (f);
    fseek (f, 0, SEEK_END);
    end = ftell (f);
    fseek (f, pos, SEEK_SET);
 
    return end;
}

Referenced by FS_FOpenFile().

FS_FOpenFile()

int FS_FOpenFile	(	char *	filename,
		FILE **	file
	)

Definition at line 206 of file files.c.

{
    searchpath_t    *search;
    char            netpath[MAX_OSPATH];
    pack_t          *pak;
    int             i;
    filelink_t      *link;
 
    file_from_pak = 0;
 
    // check for links first
    for (link = fs_links ; link ; link=link->next)
    {
        if (!strncmp (filename, link->from, link->fromlength))
        {
            Com_sprintf (netpath, sizeof(netpath), "%s%s",link->to, filename+link->fromlength);
            *file = fopen (netpath, "rb");
            if (*file)
            {       
                Com_DPrintf ("link file: %s\n",netpath);
                return FS_filelength (*file);
            }
            return -1;
        }
    }
 
//
// search through the path, one element at a time
//
    for (search = fs_searchpaths ; search ; search = search->next)
    {
    // is the element a pak file?
        if (search->pack)
        {
        // look through all the pak file elements
            pak = search->pack;
            for (i=0 ; i<pak->numfiles ; i++)
                if (!Q_strcasecmp (pak->files[i].name, filename))
                {   // found it!
                    file_from_pak = 1;
                    Com_DPrintf ("PackFile: %s : %s\n",pak->filename, filename);
                // open a new file on the pakfile
                    *file = fopen (pak->filename, "rb");
                    if (!*file)
                        Com_Error (ERR_FATAL, "Couldn't reopen %s", pak->filename); 
                    fseek (*file, pak->files[i].filepos, SEEK_SET);
                    return pak->files[i].filelen;
                }
        }
        else
        {       
    // check a file in the directory tree
            
            Com_sprintf (netpath, sizeof(netpath), "%s/%s",search->filename, filename);
            
            *file = fopen (netpath, "rb");
            if (!*file)
                continue;
            
            Com_DPrintf ("FindFile: %s\n",netpath);
 
            return FS_filelength (*file);
        }
        
    }
    
    Com_DPrintf ("FindFile: can't find %s\n", filename);
    
    *file = NULL;
    return -1;
}

Referenced by FS_LoadFile(), S_RegisterSexedSound(), SCR_PlayCinematic(), and SV_BeginDemoserver().

FS_FreeFile()

void FS_FreeFile

(

void *

buffer

)

Definition at line 433 of file files.c.

{
    Z_Free (buffer);
}

Referenced by CL_RequestNextDownload(), CM_LoadMap(), Cmd_Exec_f(), M_Credits_Key(), S_LoadSound(), SCR_LoadPCX(), StartServer_MenuInit(), SV_BeginDownload_f(), SV_DropClient(), SV_NextDownload_f(), and VID_LoadRefresh().

FS_Gamedir()

char* FS_Gamedir

(

void

)

Definition at line 590 of file files.c.

{
    return fs_gamedir;
}

Referenced by CL_DownloadFileName(), CL_Record_f(), CL_WriteConfiguration(), Com_Printf(), Con_Dump_f(), Create_Savestrings(), StartServer_MenuInit(), SV_CheckForSavegame(), SV_CopySaveGame(), SV_GameMap_f(), SV_Loadgame_f(), SV_ReadLevelFile(), SV_ReadServerFile(), SV_ServerRecord_f(), SV_WipeSavegame(), SV_WriteLevelFile(), SV_WriteServerFile(), and VID_LoadRefresh().

FS_InitFilesystem()

void FS_InitFilesystem

(

void

)

Definition at line 891 of file files.c.

{
    Cmd_AddCommand ("path", FS_Path_f);
    Cmd_AddCommand ("link", FS_Link_f);
    Cmd_AddCommand ("dir", FS_Dir_f );
 
    //
    // basedir <path>
    // allows the game to run from outside the data tree
    //
    fs_basedir = Cvar_Get ("basedir", ".", CVAR_NOSET);
 
    //
    // cddir <path>
    // Logically concatenates the cddir after the basedir for 
    // allows the game to run from outside the data tree
    //
    fs_cddir = Cvar_Get ("cddir", "", CVAR_NOSET);
    if (fs_cddir->string[0])
        FS_AddGameDirectory (va("%s/"BASEDIRNAME, fs_cddir->string) );
 
    //
    // add baseq2 to search path
    //
    FS_AddGameDirectory (va("%s/"BASEDIRNAME, fs_basedir->string) );
 
    //
    // then add a '.quake2/baseq2' directory in home directory by default
    //
    FS_AddHomeAsGameDirectory(BASEDIRNAME);
 
    // any set gamedirs will be freed up to here
    fs_base_searchpaths = fs_searchpaths;
 
    // check for game override
    fs_gamedirvar = Cvar_Get ("game", "", CVAR_LATCH|CVAR_SERVERINFO);
    if (fs_gamedirvar->string[0])
        FS_SetGamedir (fs_gamedirvar->string);
}

Referenced by Qcommon_Init().

FS_Link_f()

void FS_Link_f

(

void

)

Definition at line 696 of file files.c.

{
    filelink_t  *l, **prev;
 
    if (Cmd_Argc() != 3)
    {
        Com_Printf ("USAGE: link <from> <to>\n");
        return;
    }
 
    // see if the link already exists
    prev = &fs_links;
    for (l=fs_links ; l ; l=l->next)
    {
        if (!strcmp (l->from, Cmd_Argv(1)))
        {
            Z_Free (l->to);
            if (!strlen(Cmd_Argv(2)))
            {   // delete it
                *prev = l->next;
                Z_Free (l->from);
                Z_Free (l);
                return;
            }
            l->to = CopyString (Cmd_Argv(2));
            return;
        }
        prev = &l->next;
    }
 
    // create a new link
    l = Z_Malloc(sizeof(*l));
    l->next = fs_links;
    fs_links = l;
    l->from = CopyString(Cmd_Argv(1));
    l->fromlength = strlen(l->from);
    l->to = CopyString(Cmd_Argv(2));
}

Referenced by FS_InitFilesystem().

FS_ListFiles()

char** FS_ListFiles	(	char *	findname,
		int *	numfiles,
		unsigned	musthave,
		unsigned	canthave
	)

Definition at line 738 of file files.c.

{
    char *s;
    int nfiles = 0;
    char **list = 0;
 
    s = Sys_FindFirst( findname, musthave, canthave );
    while ( s )
    {
        if ( s[strlen(s)-1] != '.' )
            nfiles++;
        s = Sys_FindNext( musthave, canthave );
    }
    Sys_FindClose ();
 
    if ( !nfiles )
        return NULL;
 
    nfiles++; // add space for a guard
    *numfiles = nfiles;
 
    list = malloc( sizeof( char * ) * nfiles );
    memset( list, 0, sizeof( char * ) * nfiles );
 
    s = Sys_FindFirst( findname, musthave, canthave );
    nfiles = 0;
    while ( s )
    {
        if ( s[strlen(s)-1] != '.' )
        {
            list[nfiles] = strdup( s );
#ifdef _WIN32
            strlwr( list[nfiles] );
#endif
            nfiles++;
        }
        s = Sys_FindNext( musthave, canthave );
    }
    Sys_FindClose ();
 
    return list;
}

Referenced by FS_Dir_f(), and PlayerConfig_ScanDirectories().

FS_LoadFile()

int FS_LoadFile	(	char *	path,
		void **	buffer
	)

Definition at line 394 of file files.c.

{
    FILE    *h;
    byte    *buf;
    int     len;
 
    buf = NULL; // quiet compiler warning
 
// look for it in the filesystem or pack files
    len = FS_FOpenFile (path, &h);
    if (!h)
    {
        if (buffer)
            *buffer = NULL;
        return -1;
    }
    
    if (!buffer)
    {
        fclose (h);
        return len;
    }
 
    buf = Z_Malloc(len);
    *buffer = buf;
 
    FS_Read (buf, len, h);
 
    fclose (h);
 
    return len;
}

Referenced by CL_CheckOrDownloadFile(), CL_Download_f(), CL_RequestNextDownload(), CM_LoadMap(), Cmd_Exec_f(), M_Menu_Credits_f(), S_LoadSound(), SCR_LoadPCX(), StartServer_MenuInit(), SV_BeginDownload_f(), SV_Map_f(), and VID_LoadRefresh().

FS_LoadPackFile()

pack_t* FS_LoadPackFile

(

char *

packfile

)

Definition at line 448 of file files.c.

{
    dpackheader_t   header;
    int             i;
    packfile_t      *newfiles;
    int             numpackfiles;
    pack_t          *pack;
    FILE            *packhandle;
    dpackfile_t     info[MAX_FILES_IN_PACK];
    unsigned        checksum;
 
    packhandle = fopen(packfile, "rb");
    if (!packhandle)
        return NULL;
 
    fread (&header, 1, sizeof(header), packhandle);
    if (LittleLong(header.ident) != IDPAKHEADER)
        Com_Error (ERR_FATAL, "%s is not a packfile", packfile);
    header.dirofs = LittleLong (header.dirofs);
    header.dirlen = LittleLong (header.dirlen);
 
    numpackfiles = header.dirlen / sizeof(dpackfile_t);
 
    if (numpackfiles > MAX_FILES_IN_PACK)
        Com_Error (ERR_FATAL, "%s has %i files", packfile, numpackfiles);
 
    newfiles = Z_Malloc (numpackfiles * sizeof(packfile_t));
 
    fseek (packhandle, header.dirofs, SEEK_SET);
    fread (info, 1, header.dirlen, packhandle);
 
// crc the directory to check for modifications
    checksum = Com_BlockChecksum ((void *)info, header.dirlen);
 
#ifdef NO_ADDONS
    if (checksum != PAK0_CHECKSUM)
        return NULL;
#endif
// parse the directory
    for (i=0 ; i<numpackfiles ; i++)
    {
        strcpy (newfiles[i].name, info[i].name);
        newfiles[i].filepos = LittleLong(info[i].filepos);
        newfiles[i].filelen = LittleLong(info[i].filelen);
    }
 
    pack = Z_Malloc (sizeof (pack_t));
    strcpy (pack->filename, packfile);
    pack->handle = packhandle;
    pack->numfiles = numpackfiles;
    pack->files = newfiles;
    
    Com_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
    return pack;
}

Referenced by FS_AddGameDirectory().

FS_NextPath()

char* FS_NextPath

(

char *

prevpath

)

Definition at line 865 of file files.c.

{
    searchpath_t    *s;
    char            *prev;
 
    prev = NULL; /* fs_gamedir is the first directory in the searchpath */
    for (s=fs_searchpaths ; s ; s=s->next)
    {
        if (s->pack)
            continue;
        if (prevpath == NULL)
            return s->filename;
        if (prevpath == prev)
            return s->filename;
        prev = s->filename;
    }
 
    return NULL;
}

Referenced by FS_Dir_f(), PlayerConfig_ScanDirectories(), and Sys_GetGameAPI().

FS_Path_f()

void FS_Path_f

(

void

)

Definition at line 837 of file files.c.

{
    searchpath_t    *s;
    filelink_t      *l;
 
    Com_Printf ("Current search path:\n");
    for (s=fs_searchpaths ; s ; s=s->next)
    {
        if (s == fs_base_searchpaths)
            Com_Printf ("----------\n");
        if (s->pack)
            Com_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
        else
            Com_Printf ("%s\n", s->filename);
    }
 
    Com_Printf ("\nLinks:\n");
    for (l=fs_links ; l ; l=l->next)
        Com_Printf ("%s : %s\n", l->from, l->to);
}

Referenced by FS_InitFilesystem().

FS_Read()

void FS_Read	(	void *	buffer,
		int	len,
		FILE *	f
	)

Definition at line 346 of file files.c.

{
    int     block, remaining;
    int     read;
    byte    *buf;
    int     tries;
 
    buf = (byte *)buffer;
 
    // read in chunks for progress bar
    remaining = len;
    tries = 0;
    while (remaining)
    {
        block = remaining;
        if (block > MAX_READ)
            block = MAX_READ;
        read = fread (buf, 1, block, f);
        if (read == 0)
        {
            // we might have been trying to read from a CD
            if (!tries)
            {
                tries = 1;
                CDAudio_Stop();
            }
            else
                Com_Error (ERR_FATAL, "FS_Read: 0 bytes read");
        }
 
        if (read == -1)
            Com_Error (ERR_FATAL, "FS_Read: -1 bytes read");
 
        // do some progress bar thing here...
 
        remaining -= read;
        buf += read;
    }
}

Referenced by CM_ReadPortalState(), Create_Savestrings(), FS_LoadFile(), Huff1TableInit(), SCR_PlayCinematic(), SCR_ReadNextFrame(), SV_ReadLevelFile(), and SV_ReadServerFile().

FS_SetGamedir()

void FS_SetGamedir

(

char *

dir

)

Definition at line 638 of file files.c.

{
    searchpath_t    *next;
 
    if (strstr(dir, "..") || strstr(dir, "/")
        || strstr(dir, "\\") || strstr(dir, ":") )
    {
        Com_Printf ("Gamedir should be a single filename, not a path\n");
        return;
    }
 
    //
    // free up any current game dir info
    //
    while (fs_searchpaths != fs_base_searchpaths)
    {
        if (fs_searchpaths->pack)
        {
            fclose (fs_searchpaths->pack->handle);
            Z_Free (fs_searchpaths->pack->files);
            Z_Free (fs_searchpaths->pack);
        }
        next = fs_searchpaths->next;
        Z_Free (fs_searchpaths);
        fs_searchpaths = next;
    }
 
    //
    // flush all data, so it will be forced to reload
    //
    if (dedicated && !dedicated->value)
        Cbuf_AddText ("vid_restart\nsnd_restart\n");
 
 
    // now add new entries for 
    if (!strcmp(dir,BASEDIRNAME) || (*dir == 0))
    {
        Cvar_FullSet ("gamedir", "", CVAR_SERVERINFO|CVAR_NOSET);
        Cvar_FullSet ("game", "", CVAR_LATCH|CVAR_SERVERINFO);
    }
    else
    {
        Cvar_FullSet ("gamedir", dir, CVAR_SERVERINFO|CVAR_NOSET);
        if (fs_cddir->string[0])
            FS_AddGameDirectory (va("%s/%s", fs_cddir->string, dir) );
        FS_AddGameDirectory (va("%s/%s", fs_basedir->string, dir) );
        FS_AddHomeAsGameDirectory(dir);
    }
}

Referenced by Cvar_GetLatchedVars(), Cvar_Set2(), and FS_InitFilesystem().

Variable Documentation

file_from_pak

int file_from_pak = 0

Definition at line 204 of file files.c.

Referenced by FS_FOpenFile(), and SV_BeginDownload_f().

fs_base_searchpaths

searchpath_t* fs_base_searchpaths

Definition at line 84 of file files.c.

Referenced by FS_ExecAutoexec(), FS_InitFilesystem(), FS_Path_f(), and FS_SetGamedir().

fs_basedir

cvar_t* fs_basedir

Definition at line 62 of file files.c.

Referenced by FS_InitFilesystem(), and FS_SetGamedir().

fs_cddir

cvar_t* fs_cddir

Definition at line 63 of file files.c.

Referenced by FS_InitFilesystem(), and FS_SetGamedir().

fs_gamedir

char fs_gamedir[MAX_OSPATH]

Definition at line 61 of file files.c.

Referenced by FS_AddHomeAsGameDirectory(), and FS_Gamedir().

fs_gamedirvar

cvar_t* fs_gamedirvar

Definition at line 64 of file files.c.

Referenced by CL_ParseServerData(), and FS_InitFilesystem().

fs_links

filelink_t* fs_links

Definition at line 74 of file files.c.

Referenced by FS_FOpenFile(), FS_Link_f(), and FS_Path_f().

fs_searchpaths

searchpath_t* fs_searchpaths

Definition at line 83 of file files.c.

Referenced by Developer_searchpath(), FS_AddGameDirectory(), FS_ExecAutoexec(), FS_FOpenFile(), FS_InitFilesystem(), FS_NextPath(), FS_Path_f(), and FS_SetGamedir().