major overhaul for thread-safety - many global variables and static
authorhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Sat, 22 Oct 2011 23:52:58 +0000 (23:52 +0000)
committerhavoc <havoc@d7cf8633-e32d-0410-b094-e92efae38249>
Sat, 22 Oct 2011 23:52:58 +0000 (23:52 +0000)
buffers eliminated, this causes MANY changes, such as va() taking a
buffer, prog variable has to be passed as parameter to every PRVM
function, and many other edits of that nature.
realtime is now the only linearly increasing time stamp in the engine,
Sys_DoubleTime replaced by Sys_DirtyTime which requires sanity checks in
every use, but ensures thread-safe behavior
added -Wmissing-prototypes to makefile so that no one will ever put an
extern function prototype in a .c file again, this was necessary to
clean up crashes where prototype parameters differed.

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@11463 d7cf8633-e32d-0410-b094-e92efae38249

101 files changed:
cap_avi.c
cap_ogg.c
cd_shared.c
cdaudio.h
cl_collision.c
cl_demo.c
cl_input.c
cl_main.c
cl_parse.c
cl_particles.c
cl_screen.c
cl_video.c
cl_video_jamdecode.c
client.h
clvm_cmds.c
clvm_cmds.h
cmd.c
cmd.h
collision.c
common.c
common.h
console.c
console.h
crypto.c
csprogs.c
csprogs.h
curves.c
cvar.c
dpsoftrast.c
dpvsimpledecode.c
fs.c
fs.h
ft2.c
gl_backend.c
gl_draw.c
gl_rmain.c
gl_rsurf.c
gl_textures.c
host.c
host_cmd.c
image.c
image_png.c
jpeg.c
keys.c
keys.h
lhnet.c
lhnet.h
libcurl.c
libcurl.h
makefile
mathlib.h
menu.c
menu.h
model_alias.c
model_brush.c
model_shared.c
model_sprite.c
mvm_cmds.c
netconn.c
netconn.h
palette.c
portals.c
progsvm.h
protocol.c
prvm_cmds.c
prvm_cmds.h
prvm_edict.c
prvm_exec.c
prvm_execprogram.h
quakedef.h
r_lightning.c
r_shadow.c
r_sky.c
r_sprites.c
r_textures.h
render.h
sbar.c
sbar.h
server.h
snd_main.c
snd_mix.c
sound.h
sv_demo.c
sv_main.c
sv_move.c
sv_phys.c
sv_user.c
svvm_cmds.c
sys.h
sys_shared.c
timing.h
utf8lib.c
utf8lib.h
vid.h
vid_glx.c
vid_sdl.c
vid_shared.c
view.c
world.c
world.h
zone.c

index 4862436..9a238e8 100644 (file)
--- a/cap_avi.c
+++ b/cap_avi.c
@@ -188,7 +188,7 @@ static void SCR_CaptureVideo_RIFF_IndexEntry(const char *chunkfourcc, int chunks
 {
        LOAD_FORMATSPECIFIC_AVI();
        if(!format->canseek)
-               Host_Error("SCR_CaptureVideo_RIFF_IndexEntry called on non-seekable AVI");
+               Sys_Error("SCR_CaptureVideo_RIFF_IndexEntry called on non-seekable AVI");
 
        if (format->riffstacklevel != 2)
                Sys_Error("SCR_Capturevideo_RIFF_IndexEntry: RIFF stack level is %i (should be 2)\n", format->riffstacklevel);
@@ -209,7 +209,7 @@ static void SCR_CaptureVideo_RIFF_MakeIxChunk(const char *fcc, const char *dwChu
        fs_offset_t pos, sz;
        
        if(!format->canseek)
-               Host_Error("SCR_CaptureVideo_RIFF_MakeIxChunk called on non-seekable AVI");
+               Sys_Error("SCR_CaptureVideo_RIFF_MakeIxChunk called on non-seekable AVI");
 
        if(*masteridx_count >= AVI_MASTER_INDEX_SIZE)
                return;
@@ -404,7 +404,7 @@ static void SCR_CaptureVideo_Avi_VideoFrames(int num)
        }
 }
 
-void SCR_CaptureVideo_Avi_EndVideo(void)
+static void SCR_CaptureVideo_Avi_EndVideo(void)
 {
        LOAD_FORMATSPECIFIC_AVI();
 
@@ -449,7 +449,7 @@ void SCR_CaptureVideo_Avi_EndVideo(void)
        Mem_Free(format);
 }
 
-void SCR_CaptureVideo_Avi_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length)
+static void SCR_CaptureVideo_Avi_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length)
 {
        LOAD_FORMATSPECIFIC_AVI();
        int x;
@@ -502,12 +502,13 @@ void SCR_CaptureVideo_Avi_BeginVideo(void)
        int n, d;
        unsigned int i;
        double aspect;
+       char vabuf[1024];
 
        aspect = vid.width / (vid.height * vid_pixelheight.value);
 
        cls.capturevideo.format = CAPTUREVIDEOFORMAT_AVI_I420;
        cls.capturevideo.formatextension = "avi";
-       cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
+       cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
        cls.capturevideo.endvideo = SCR_CaptureVideo_Avi_EndVideo;
        cls.capturevideo.videoframes = SCR_CaptureVideo_Avi_VideoFrames;
        cls.capturevideo.soundframe = SCR_CaptureVideo_Avi_SoundFrame;
index 166ead0..de3132d 100644 (file)
--- a/cap_ogg.c
+++ b/cap_ogg.c
@@ -523,7 +523,7 @@ static dllfunction_t theorafuncs[] =
 
 static dllhandle_t og_dll = NULL, vo_dll = NULL, ve_dll = NULL, th_dll = NULL;
 
-qboolean SCR_CaptureVideo_Ogg_OpenLibrary(void)
+static qboolean SCR_CaptureVideo_Ogg_OpenLibrary(void)
 {
        const char* dllnames_og [] =
        {
@@ -677,7 +677,7 @@ static void SCR_CaptureVideo_Ogg_Interleave(void)
                                format->videopage.len = pg.header_len + pg.body_len;
                                format->videopage.time = qtheora_granule_time(&format->ts, qogg_page_granulepos(&pg));
                                if(format->videopage.len > sizeof(format->videopage.data))
-                                       Host_Error("video page too long");
+                                       Sys_Error("video page too long");
                                memcpy(format->videopage.data, pg.header, pg.header_len);
                                memcpy(format->videopage.data + pg.header_len, pg.body, pg.body_len);
                        }
@@ -687,7 +687,7 @@ static void SCR_CaptureVideo_Ogg_Interleave(void)
                                format->audiopage.len = pg.header_len + pg.body_len;
                                format->audiopage.time = qvorbis_granule_time(&format->vd, qogg_page_granulepos(&pg));
                                if(format->audiopage.len > sizeof(format->audiopage.data))
-                                       Host_Error("audio page too long");
+                                       Sys_Error("audio page too long");
                                memcpy(format->audiopage.data, pg.header, pg.header_len);
                                memcpy(format->audiopage.data + pg.header_len, pg.body, pg.body_len);
                        }
@@ -782,7 +782,7 @@ static void SCR_CaptureVideo_Ogg_EndVideo(void)
        while (1) {
                int result = qogg_stream_flush (&format->to, &pg);
                if (result < 0)
-                       fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
+                       fprintf (stderr, "Internal Ogg library error.\n"); // TODO Sys_Error
                if (result <= 0)
                        break;
                FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
@@ -794,7 +794,7 @@ static void SCR_CaptureVideo_Ogg_EndVideo(void)
                while (1) {
                        int result = qogg_stream_flush (&format->vo, &pg);
                        if (result < 0)
-                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
+                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Sys_Error
                        if (result <= 0)
                                break;
                        FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
@@ -937,9 +937,10 @@ static void SCR_CaptureVideo_Ogg_SoundFrame(const portable_sampleframe_t *paintb
 
 void SCR_CaptureVideo_Ogg_BeginVideo(void)
 {
+       char vabuf[1024];
        cls.capturevideo.format = CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA;
        cls.capturevideo.formatextension = "ogv";
-       cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
+       cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
        cls.capturevideo.endvideo = SCR_CaptureVideo_Ogg_EndVideo;
        cls.capturevideo.videoframes = SCR_CaptureVideo_Ogg_VideoFrames;
        cls.capturevideo.soundframe = SCR_CaptureVideo_Ogg_SoundFrame;
@@ -1098,7 +1099,7 @@ void SCR_CaptureVideo_Ogg_BeginVideo(void)
                {
                        int result = qogg_stream_flush (&format->to, &pg);
                        if (result < 0)
-                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
+                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Sys_Error
                        if (result <= 0)
                                break;
                        FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
@@ -1110,7 +1111,7 @@ void SCR_CaptureVideo_Ogg_BeginVideo(void)
                {
                        int result = qogg_stream_flush (&format->vo, &pg);
                        if (result < 0)
-                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
+                               fprintf (stderr, "Internal Ogg library error.\n"); // TODO Sys_Error
                        if (result <= 0)
                                break;
                        FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
index cd12235..43b4a7f 100644 (file)
@@ -24,21 +24,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "cdaudio.h"
 #include "sound.h"
 
-// Prototypes of the system dependent functions
-extern void CDAudio_SysEject (void);
-extern void CDAudio_SysCloseDoor (void);
-extern int CDAudio_SysGetAudioDiskInfo (void);
-extern float CDAudio_SysGetVolume (void);
-extern void CDAudio_SysSetVolume (float volume);
-extern int CDAudio_SysPlay (int track);
-extern int CDAudio_SysStop (void);
-extern int CDAudio_SysPause (void);
-extern int CDAudio_SysResume (void);
-extern int CDAudio_SysUpdate (void);
-extern void CDAudio_SysInit (void);
-extern int CDAudio_SysStartup (void);
-extern void CDAudio_SysShutdown (void);
-
 // used by menu to ghost CD audio slider
 cvar_t cdaudioinitialized = {CVAR_READONLY,"cdaudioinitialized","0","indicates if CD Audio system is active"};
 cvar_t cdaudio = {CVAR_SAVE,"cdaudio","1","CD playing mode (0 = never access CD drive, 1 = play CD tracks if no replacement available, 2 = play fake tracks if no CD track available, 3 = play only real CD tracks, 4 = play real CD tracks even instead of named fake tracks)"};
@@ -164,7 +149,7 @@ static int CDAudio_GetAudioDiskInfo (void)
        return 0;
 }
 
-qboolean CDAudio_Play_real (int track, qboolean looping, qboolean complain)
+static qboolean CDAudio_Play_real (int track, qboolean looping, qboolean complain)
 {
        if(track < 1)
        {
@@ -583,7 +568,7 @@ static void CD_f (void)
        Con_Printf("cd info - prints basic disc information (number of tracks, currently playing track, volume level)\n");
 }
 
-void CDAudio_SetVolume (float newvol)
+static void CDAudio_SetVolume (float newvol)
 {
        // If the volume hasn't changed
        if (newvol == cdvolume)
index 3fed67f..5eac430 100644 (file)
--- a/cdaudio.h
+++ b/cdaudio.h
@@ -49,3 +49,18 @@ void CDAudio_Shutdown(void);
 void CDAudio_Update(void);
 float CDAudio_GetPosition(void);
 void CDAudio_StartPlaylist(qboolean resume);
+
+// Prototypes of the system dependent functions
+void CDAudio_SysEject (void);
+void CDAudio_SysCloseDoor (void);
+int CDAudio_SysGetAudioDiskInfo (void);
+float CDAudio_SysGetVolume (void);
+void CDAudio_SysSetVolume (float volume);
+int CDAudio_SysPlay (int track);
+int CDAudio_SysStop (void);
+int CDAudio_SysPause (void);
+int CDAudio_SysResume (void);
+int CDAudio_SysUpdate (void);
+void CDAudio_SysInit (void);
+int CDAudio_SysStartup (void);
+void CDAudio_SysShutdown (void);
index 6829863..1fc448d 100644 (file)
@@ -128,6 +128,7 @@ dp_model_t *CL_GetModelByIndex(int modelindex)
 
 dp_model_t *CL_GetModelFromEdict(prvm_edict_t *ed)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if (!ed || ed->priv.server->free)
                return NULL;
        return CL_GetModelByIndex((int)PRVM_clientedictfloat(ed, modelindex));
@@ -135,6 +136,7 @@ dp_model_t *CL_GetModelFromEdict(prvm_edict_t *ed)
 
 void CL_LinkEdict(prvm_edict_t *ent)
 {
+       prvm_prog_t *prog = CLVM_prog;
        vec3_t mins, maxs;
 
        if (ent == prog->edicts)
@@ -197,6 +199,7 @@ void CL_LinkEdict(prvm_edict_t *ent)
 
 int CL_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
 {
+       prvm_prog_t *prog = CLVM_prog;
        if (passedict)
        {
                int dphitcontentsmask = (int)PRVM_clientedictfloat(passedict, dphitcontentsmask);
@@ -227,6 +230,7 @@ CL_Move
 */
 trace_t CL_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int hitsupercontentsmask, qboolean hitnetworkbrushmodels, qboolean hitnetworkplayers, int *hitnetworkentity, qboolean hitcsqcentities)
 {
+       prvm_prog_t *prog = CLVM_prog;
        int i, bodysupercontents;
        int passedictprog;
        prvm_edict_t *traceowner, *touch;
@@ -439,6 +443,7 @@ trace_t CL_TraceLine(const vec3_t start, const vec3_t pEnd, int type, prvm_edict
 trace_t CL_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, qboolean hitnetworkbrushmodels, qboolean hitnetworkplayers, int *hitnetworkentity, qboolean hitcsqcentities, qboolean hitsurfaces)
 #endif
 {
+       prvm_prog_t *prog = CLVM_prog;
        int i, bodysupercontents;
        int passedictprog;
        prvm_edict_t *traceowner, *touch;
@@ -676,6 +681,7 @@ trace_t CL_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
 trace_t CL_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int type, prvm_edict_t *passedict, int hitsupercontentsmask, qboolean hitnetworkbrushmodels, qboolean hitnetworkplayers, int *hitnetworkentity, qboolean hitcsqcentities)
 #endif
 {
+       prvm_prog_t *prog = CLVM_prog;
        vec3_t hullmins, hullmaxs;
        int i, bodysupercontents;
        int passedictprog;
@@ -950,6 +956,7 @@ trace_t CL_Cache_TraceLineSurfaces(const vec3_t start, const vec3_t pEnd, int ty
 trace_t CL_Cache_TraceLineSurfaces(const vec3_t start, const vec3_t end, int type, int hitsupercontentsmask)
 #endif
 {
+       prvm_prog_t *prog = CLVM_prog;
        int i;
        prvm_edict_t *touch;
        trace_t trace;
index 6778917..6c2b36d 100644 (file)
--- a/cl_demo.c
+++ b/cl_demo.c
@@ -23,7 +23,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 extern cvar_t cl_capturevideo;
 int old_vsync = 0;
 
-void CL_FinishTimeDemo (void);
+static void CL_FinishTimeDemo (void);
 
 /*
 ==============================================================================
@@ -138,7 +138,7 @@ void CL_CutDemo (unsigned char **buf, fs_offset_t *filesize)
        // restart the demo recording
        cls.demofile = FS_OpenRealFile(cls.demoname, "wb", false);
        if(!cls.demofile)
-               Host_Error("failed to reopen the demo file");
+               Sys_Error("failed to reopen the demo file");
        FS_Printf(cls.demofile, "%i\n", cls.forcetrack);
 }
 
@@ -238,16 +238,21 @@ void CL_ReadDemoMessage(void)
                }
 
                // get the next message
-               FS_Read(cls.demofile, &net_message.cursize, 4);
-               net_message.cursize = LittleLong(net_message.cursize);
-               if(net_message.cursize & DEMOMSG_CLIENT_TO_SERVER) // This is a client->server message! Ignore for now!
+               FS_Read(cls.demofile, &cl_message.cursize, 4);
+               cl_message.cursize = LittleLong(cl_message.cursize);
+               if(cl_message.cursize & DEMOMSG_CLIENT_TO_SERVER) // This is a client->server message! Ignore for now!
                {
                        // skip over demo packet
-                       FS_Seek(cls.demofile, 12 + (net_message.cursize & (~DEMOMSG_CLIENT_TO_SERVER)), SEEK_CUR);
+                       FS_Seek(cls.demofile, 12 + (cl_message.cursize & (~DEMOMSG_CLIENT_TO_SERVER)), SEEK_CUR);
                        continue;
                }
-               if (net_message.cursize > net_message.maxsize)
-                       Host_Error("Demo message (%i) > net_message.maxsize (%i)", net_message.cursize, net_message.maxsize);
+               if (cl_message.cursize > cl_message.maxsize)
+               {
+                       Con_Printf("Demo message (%i) > cl_message.maxsize (%i)", cl_message.cursize, cl_message.maxsize);
+                       cl_message.cursize = 0;
+                       CL_Disconnect();
+                       return;
+               }
                VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
                for (i = 0;i < 3;i++)
                {
@@ -255,9 +260,9 @@ void CL_ReadDemoMessage(void)
                        cl.mviewangles[0][i] = LittleFloat(f);
                }
 
-               if (FS_Read(cls.demofile, net_message.data, net_message.cursize) == net_message.cursize)
+               if (FS_Read(cls.demofile, cl_message.data, cl_message.cursize) == cl_message.cursize)
                {
-                       MSG_BeginReading();
+                       MSG_BeginReading(&cl_message);
                        CL_ParseServerMessage();
 
                        if (cls.signon != SIGNONS)
@@ -298,7 +303,7 @@ void CL_Stop_f (void)
        }
 
 // write a disconnect message to the demo file
-       // LordHavoc: don't replace the net_message when doing this
+       // LordHavoc: don't replace the cl_message when doing this
        buf.data = bufdata;
        buf.maxsize = sizeof(bufdata);
        SZ_Clear(&buf);
@@ -329,6 +334,7 @@ void CL_Record_f (void)
 {
        int c, track;
        char name[MAX_OSPATH];
+       char vabuf[1024];
 
        c = Cmd_Argc();
        if (c != 2 && c != 3 && c != 4)
@@ -367,7 +373,7 @@ void CL_Record_f (void)
 
        // start the map up
        if (c > 2)
-               Cmd_ExecuteString ( va("map %s", Cmd_Argv(2)), src_command, false);
+               Cmd_ExecuteString ( va(vabuf, sizeof(vabuf), "map %s", Cmd_Argv(2)), src_command, false);
 
        // open the demo file
        Con_Printf("recording to %s.\n", name);
@@ -449,13 +455,14 @@ CL_FinishTimeDemo
 
 ====================
 */
-void CL_FinishTimeDemo (void)
+static void CL_FinishTimeDemo (void)
 {
        int frames;
        int i;
        double time, totalfpsavg;
        double fpsmin, fpsavg, fpsmax; // report min/avg/max fps
        static int benchmark_runs = 0;
+       char vabuf[1024];
 
        cls.timedemo = false;
 
@@ -477,7 +484,7 @@ void CL_FinishTimeDemo (void)
                        if(atoi(com_argv[i + 1]) > benchmark_runs)
                        {
                                // restart the benchmark
-                               Cbuf_AddText(va("timedemo %s\n", cls.demoname));
+                               Cbuf_AddText(va(vabuf, sizeof(vabuf), "timedemo %s\n", cls.demoname));
                                // cannot execute here
                        }
                        else
index a0a2957..6959b14 100644 (file)
@@ -61,7 +61,7 @@ int                   in_impulse;
 
 
 
-void KeyDown (kbutton_t *b)
+static void KeyDown (kbutton_t *b)
 {
        int k;
        const char *c;
@@ -90,7 +90,7 @@ void KeyDown (kbutton_t *b)
        b->state |= 1 + 2;      // down + impulse down
 }
 
-void KeyUp (kbutton_t *b)
+static void KeyUp (kbutton_t *b)
 {
        int k;
        const char *c;
@@ -120,86 +120,86 @@ void KeyUp (kbutton_t *b)
        b->state |= 4;          // impulse up
 }
 
-void IN_KLookDown (void) {KeyDown(&in_klook);}
-void IN_KLookUp (void) {KeyUp(&in_klook);}
-void IN_MLookDown (void) {KeyDown(&in_mlook);}
-void IN_MLookUp (void)
+static void IN_KLookDown (void) {KeyDown(&in_klook);}
+static void IN_KLookUp (void) {KeyUp(&in_klook);}
+static void IN_MLookDown (void) {KeyDown(&in_mlook);}
+static void IN_MLookUp (void)
 {
        KeyUp(&in_mlook);
        if ( !(in_mlook.state&1) && lookspring.value)
                V_StartPitchDrift();
 }
-void IN_UpDown(void) {KeyDown(&in_up);}
-void IN_UpUp(void) {KeyUp(&in_up);}
-void IN_DownDown(void) {KeyDown(&in_down);}
-void IN_DownUp(void) {KeyUp(&in_down);}
-void IN_LeftDown(void) {KeyDown(&in_left);}
-void IN_LeftUp(void) {KeyUp(&in_left);}
-void IN_RightDown(void) {KeyDown(&in_right);}
-void IN_RightUp(void) {KeyUp(&in_right);}
-void IN_ForwardDown(void) {KeyDown(&in_forward);}
-void IN_ForwardUp(void) {KeyUp(&in_forward);}
-void IN_BackDown(void) {KeyDown(&in_back);}
-void IN_BackUp(void) {KeyUp(&in_back);}
-void IN_LookupDown(void) {KeyDown(&in_lookup);}
-void IN_LookupUp(void) {KeyUp(&in_lookup);}
-void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
-void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
-void IN_MoveleftDown(void) {KeyDown(&in_moveleft);}
-void IN_MoveleftUp(void) {KeyUp(&in_moveleft);}
-void IN_MoverightDown(void) {KeyDown(&in_moveright);}
-void IN_MoverightUp(void) {KeyUp(&in_moveright);}
-
-void IN_SpeedDown(void) {KeyDown(&in_speed);}
-void IN_SpeedUp(void) {KeyUp(&in_speed);}
-void IN_StrafeDown(void) {KeyDown(&in_strafe);}
-void IN_StrafeUp(void) {KeyUp(&in_strafe);}
-
-void IN_AttackDown(void) {KeyDown(&in_attack);}
-void IN_AttackUp(void) {KeyUp(&in_attack);}
-
-void IN_UseDown(void) {KeyDown(&in_use);}
-void IN_UseUp(void) {KeyUp(&in_use);}
+static void IN_UpDown(void) {KeyDown(&in_up);}
+static void IN_UpUp(void) {KeyUp(&in_up);}
+static void IN_DownDown(void) {KeyDown(&in_down);}
+static void IN_DownUp(void) {KeyUp(&in_down);}
+static void IN_LeftDown(void) {KeyDown(&in_left);}
+static void IN_LeftUp(void) {KeyUp(&in_left);}
+static void IN_RightDown(void) {KeyDown(&in_right);}
+static void IN_RightUp(void) {KeyUp(&in_right);}
+static void IN_ForwardDown(void) {KeyDown(&in_forward);}
+static void IN_ForwardUp(void) {KeyUp(&in_forward);}
+static void IN_BackDown(void) {KeyDown(&in_back);}
+static void IN_BackUp(void) {KeyUp(&in_back);}
+static void IN_LookupDown(void) {KeyDown(&in_lookup);}
+static void IN_LookupUp(void) {KeyUp(&in_lookup);}
+static void IN_LookdownDown(void) {KeyDown(&in_lookdown);}
+static void IN_LookdownUp(void) {KeyUp(&in_lookdown);}
+static void IN_MoveleftDown(void) {KeyDown(&in_moveleft);}
+static void IN_MoveleftUp(void) {KeyUp(&in_moveleft);}
+static void IN_MoverightDown(void) {KeyDown(&in_moveright);}
+static void IN_MoverightUp(void) {KeyUp(&in_moveright);}
+
+static void IN_SpeedDown(void) {KeyDown(&in_speed);}
+static void IN_SpeedUp(void) {KeyUp(&in_speed);}
+static void IN_StrafeDown(void) {KeyDown(&in_strafe);}
+static void IN_StrafeUp(void) {KeyUp(&in_strafe);}
+
+static void IN_AttackDown(void) {KeyDown(&in_attack);}
+static void IN_AttackUp(void) {KeyUp(&in_attack);}
+
+static void IN_UseDown(void) {KeyDown(&in_use);}
+static void IN_UseUp(void) {KeyUp(&in_use);}
 
 // LordHavoc: added 6 new buttons
-void IN_Button3Down(void) {KeyDown(&in_button3);}
-void IN_Button3Up(void) {KeyUp(&in_button3);}
-void IN_Button4Down(void) {KeyDown(&in_button4);}
-void IN_Button4Up(void) {KeyUp(&in_button4);}
-void IN_Button5Down(void) {KeyDown(&in_button5);}
-void IN_Button5Up(void) {KeyUp(&in_button5);}
-void IN_Button6Down(void) {KeyDown(&in_button6);}
-void IN_Button6Up(void) {KeyUp(&in_button6);}
-void IN_Button7Down(void) {KeyDown(&in_button7);}
-void IN_Button7Up(void) {KeyUp(&in_button7);}
-void IN_Button8Down(void) {KeyDown(&in_button8);}
-void IN_Button8Up(void) {KeyUp(&in_button8);}
-
-void IN_Button9Down(void) {KeyDown(&in_button9);}
-void IN_Button9Up(void) {KeyUp(&in_button9);}
-void IN_Button10Down(void) {KeyDown(&in_button10);}
-void IN_Button10Up(void) {KeyUp(&in_button10);}
-void IN_Button11Down(void) {KeyDown(&in_button11);}
-void IN_Button11Up(void) {KeyUp(&in_button11);}
-void IN_Button12Down(void) {KeyDown(&in_button12);}
-void IN_Button12Up(void) {KeyUp(&in_button12);}
-void IN_Button13Down(void) {KeyDown(&in_button13);}
-void IN_Button13Up(void) {KeyUp(&in_button13);}
-void IN_Button14Down(void) {KeyDown(&in_button14);}
-void IN_Button14Up(void) {KeyUp(&in_button14);}
-void IN_Button15Down(void) {KeyDown(&in_button15);}
-void IN_Button15Up(void) {KeyUp(&in_button15);}
-void IN_Button16Down(void) {KeyDown(&in_button16);}
-void IN_Button16Up(void) {KeyUp(&in_button16);}
-
-void IN_JumpDown (void) {KeyDown(&in_jump);}
-void IN_JumpUp (void) {KeyUp(&in_jump);}
-
-void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));}
+static void IN_Button3Down(void) {KeyDown(&in_button3);}
+static void IN_Button3Up(void) {KeyUp(&in_button3);}
+static void IN_Button4Down(void) {KeyDown(&in_button4);}
+static void IN_Button4Up(void) {KeyUp(&in_button4);}
+static void IN_Button5Down(void) {KeyDown(&in_button5);}
+static void IN_Button5Up(void) {KeyUp(&in_button5);}
+static void IN_Button6Down(void) {KeyDown(&in_button6);}
+static void IN_Button6Up(void) {KeyUp(&in_button6);}
+static void IN_Button7Down(void) {KeyDown(&in_button7);}
+static void IN_Button7Up(void) {KeyUp(&in_button7);}
+static void IN_Button8Down(void) {KeyDown(&in_button8);}
+static void IN_Button8Up(void) {KeyUp(&in_button8);}
+
+static void IN_Button9Down(void) {KeyDown(&in_button9);}
+static void IN_Button9Up(void) {KeyUp(&in_button9);}
+static void IN_Button10Down(void) {KeyDown(&in_button10);}
+static void IN_Button10Up(void) {KeyUp(&in_button10);}
+static void IN_Button11Down(void) {KeyDown(&in_button11);}
+static void IN_Button11Up(void) {KeyUp(&in_button11);}
+static void IN_Button12Down(void) {KeyDown(&in_button12);}
+static void IN_Button12Up(void) {KeyUp(&in_button12);}
+static void IN_Button13Down(void) {KeyDown(&in_button13);}
+static void IN_Button13Up(void) {KeyUp(&in_button13);}
+static void IN_Button14Down(void) {KeyDown(&in_button14);}
+static void IN_Button14Up(void) {KeyUp(&in_button14);}
+static void IN_Button15Down(void) {KeyDown(&in_button15);}
+static void IN_Button15Up(void) {KeyUp(&in_button15);}
+static void IN_Button16Down(void) {KeyDown(&in_button16);}
+static void IN_Button16Up(void) {KeyUp(&in_button16);}
+
+static void IN_JumpDown (void) {KeyDown(&in_jump);}
+static void IN_JumpUp (void) {KeyUp(&in_jump);}
+
+static void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));}
 
 in_bestweapon_info_t in_bestweapon_info[IN_BESTWEAPON_MAX];
 
-void IN_BestWeapon_Register(const char *name, int impulse, int weaponbit, int activeweaponcode, int ammostat, int ammomin)
+static void IN_BestWeapon_Register(const char *name, int impulse, int weaponbit, int activeweaponcode, int ammostat, int ammomin)
 {
        int i;
        for(i = 0; i < IN_BESTWEAPON_MAX && in_bestweapon_info[i].impulse; ++i)
@@ -240,7 +240,7 @@ void IN_BestWeapon_ResetData (void)
        IN_BestWeapon_Register("h", 226, HIT_MJOLNIR, HIT_MJOLNIR, STAT_CELLS, 0); // hipnotic mjolnir hammer
 }
 
-void IN_BestWeapon_Register_f (void)
+static void IN_BestWeapon_Register_f (void)
 {
        if(Cmd_Argc() == 7)
        {
@@ -267,7 +267,7 @@ void IN_BestWeapon_Register_f (void)
        }
 }
 
-void IN_BestWeapon (void)
+static void IN_BestWeapon (void)
 {
        int i, n;
        const char *t;
@@ -468,7 +468,7 @@ CL_AdjustAngles
 Moves the local angle positions
 ================
 */
-void CL_AdjustAngles (void)
+static void CL_AdjustAngles (void)
 {
        float   speed;
        float   up, down;
@@ -518,7 +518,6 @@ CL_Input
 Send the intended movement message to the server
 ================
 */
-extern qboolean CL_VM_InputEvent (int eventtype, int x, int y);
 void CL_Input (void)
 {
        float mx, my;
@@ -756,7 +755,7 @@ void CL_Input (void)
 
 #include "cl_collision.h"
 
-void CL_UpdatePrydonCursor(void)
+static void CL_UpdatePrydonCursor(void)
 {
        vec3_t temp;
 
@@ -864,7 +863,7 @@ static vec3_t offsets[NUMOFFSETS] =
        {-0.125,  0.125, -0.125}, { 0.125,  0.125, -0.125},
 };
 
-qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
+static qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
 {
        int i;
        vec3_t neworigin;
@@ -881,7 +880,7 @@ qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s)
        return false;
 }
 
-void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
+static void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
 {
        vec_t f;
        vec3_t origin1, origin2;
@@ -957,7 +956,7 @@ void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s)
                s->waterjumptime = 0;
 }
 
-void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
+static void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
 {
        int bump;
        double t;
@@ -1019,7 +1018,7 @@ void CL_ClientMovement_Move(cl_clientmovement_state_t *s)
 }
 
 
-void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
+static void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s)
 {
        vec_t wishspeed;
        vec_t f;
@@ -1146,7 +1145,7 @@ static vec_t CL_GeomLerp(vec_t a, vec_t lerp, vec_t b)
        return a * pow(fabs(b / a), lerp);
 }
 
-void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
+static void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
 {
        vec_t zspeed, speed, dot, k;
 
@@ -1181,7 +1180,7 @@ void CL_ClientMovement_Physics_CPM_PM_Aircontrol(cl_clientmovement_state_t *s, v
        s->velocity[2] = zspeed;
 }
 
-float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
+static float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
 {
        return
                (accelqw < 0 ? -1 : +1)
@@ -1189,7 +1188,7 @@ float CL_ClientMovement_Physics_AdjustAirAccelQW(float accelqw, float factor)
                bound(0.000001, 1 - (1 - fabs(accelqw)) * factor, 1);
 }
 
-void CL_ClientMovement_Physics_PM_Accelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed, vec_t wishspeed0, vec_t accel, vec_t accelqw, vec_t stretchfactor, vec_t sidefric, vec_t speedlimit)
+static void CL_ClientMovement_Physics_PM_Accelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed, vec_t wishspeed0, vec_t accel, vec_t accelqw, vec_t stretchfactor, vec_t sidefric, vec_t speedlimit)
 {
        vec_t vel_straight;
        vec_t vel_z;
@@ -1269,7 +1268,7 @@ void CL_ClientMovement_Physics_PM_Accelerate(cl_clientmovement_state_t *s, vec3_
        s->velocity[2] += vel_z;
 }
 
-void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
+static void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, vec3_t wishdir, vec_t wishspeed)
 {
     vec3_t curvel, wishvel, acceldir, curdir;
     float addspeed, accelspeed, curspeed;
@@ -1320,7 +1319,7 @@ void CL_ClientMovement_Physics_PM_AirAccelerate(cl_clientmovement_state_t *s, ve
     VectorMA( s->velocity, accelspeed, acceldir, s->velocity );
 }
 
-void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
+static void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
 {
        vec_t friction;
        vec_t wishspeed;
@@ -1474,7 +1473,7 @@ void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s)
        }
 }
 
-void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
+static void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s)
 {
        //Con_Printf(" %f", frametime);
        if (!s->cmd.jump)
@@ -1691,7 +1690,7 @@ void CL_ClientMovement_Replay(void)
        cl.oldonground = cl.onground;
 }
 
-void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
+static void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to)
 {
        int bits;
 
@@ -2156,7 +2155,9 @@ void CL_SendMove(void)
        {
                Con_Print("CL_SendMove: lost server connection\n");
                CL_Disconnect();
+               SV_LockThreadMutex();
                Host_ShutdownServer();
+               SV_UnlockThreadMutex();
        }
 }
 
index d0d9fa9..9071b89 100644 (file)
--- a/cl_main.c
+++ b/cl_main.c
@@ -104,7 +104,6 @@ CL_ClearState
 
 =====================
 */
-void CL_VM_ShutDown (void);
 void CL_ClearState(void)
 {
        int i;
@@ -216,6 +215,7 @@ void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allo
 {
        int i;
        qboolean fail = false;
+       char vabuf[1024];
        if (!allowstarkey && key[0] == '*')
                fail = true;
        if (!allowmodel && (!strcasecmp(key, "pmodel") || !strcasecmp(key, "emodel")))
@@ -238,22 +238,22 @@ void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allo
                if (cls.protocol == PROTOCOL_QUAKEWORLD)
                {
                        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("setinfo \"%s\" \"%s\"", key, value));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "setinfo \"%s\" \"%s\"", key, value));
                }
                else if (!strcasecmp(key, "name"))
                {
                        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("name \"%s\"", value));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "name \"%s\"", value));
                }
                else if (!strcasecmp(key, "playermodel"))
                {
                        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("playermodel \"%s\"", value));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "playermodel \"%s\"", value));
                }
                else if (!strcasecmp(key, "playerskin"))
                {
                        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("playerskin \"%s\"", value));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "playerskin \"%s\"", value));
                }
                else if (!strcasecmp(key, "topcolor"))
                {
@@ -266,7 +266,7 @@ void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allo
                else if (!strcasecmp(key, "rate"))
                {
                        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("rate \"%s\"", value));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "rate \"%s\"", value));
                }
        }
 }
@@ -390,6 +390,7 @@ void CL_Disconnect(void)
                cls.netcon = NULL;
        }
        cls.state = ca_disconnected;
+       cl.islocalgame = false;
 
        cls.demoplayback = cls.timedemo = false;
        cls.signon = 0;
@@ -435,9 +436,6 @@ void CL_EstablishConnection(const char *host, int firstarg)
        // make sure the client ports are open before attempting to connect
        NetConn_UpdateSockets();
 
-       // run a network frame
-       //NetConn_ClientFrame();SV_VM_Begin();NetConn_ServerFrame();SV_VM_End();
-
        if (LHNETADDRESS_FromString(&cls.connect_address, host, 26000) && (cls.connect_mysocket = NetConn_ChooseClientSocketForAddress(&cls.connect_address)))
        {
                cls.connect_trying = true;
@@ -460,15 +458,6 @@ void CL_EstablishConnection(const char *host, int firstarg)
                }
 
                M_Update_Return_Reason("Trying to connect...");
-
-               // run several network frames to jump into the game quickly
-               //if (sv.active)
-               //{
-               //      NetConn_ClientFrame();SV_VM_Begin();NetConn_ServerFrame();SV_VM_End();
-               //      NetConn_ClientFrame();SV_VM_Begin();NetConn_ServerFrame();SV_VM_End();
-               //      NetConn_ClientFrame();SV_VM_Begin();NetConn_ServerFrame();SV_VM_End();
-               //      NetConn_ClientFrame();SV_VM_Begin();NetConn_ServerFrame();SV_VM_End();
-               //}
        }
        else
        {
@@ -754,7 +743,7 @@ void CL_AllocLightFlash(entity_render_t *ent, matrix4x4_t *matrix, float radius,
        dl->specularscale = specularscale;
 }
 
-void CL_DecayLightFlashes(void)
+static void CL_DecayLightFlashes(void)
 {
        int i, oldmax;
        dlight_t *dl;
@@ -854,7 +843,7 @@ void CL_RelinkLightFlashes(void)
        }
 }
 
-void CL_AddQWCTFFlagModel(entity_t *player, int skin)
+static void CL_AddQWCTFFlagModel(entity_t *player, int skin)
 {
        int frame = player->render.framegroupblend[0].frame;
        float f;
@@ -913,11 +902,6 @@ matrix4x4_t viewmodelmatrix_nobob;
 
 static const vec3_t muzzleflashorigin = {18, 0, 0};
 
-extern void V_DriftPitch(void);
-extern void V_FadeViewFlashs(void);
-extern void V_CalcViewBlend(void);
-extern void V_CalcRefdef(void);
-
 void CL_SetEntityColormapColors(entity_render_t *ent, int colormap)
 {
        const unsigned char *cbcolor;
@@ -936,7 +920,7 @@ void CL_SetEntityColormapColors(entity_render_t *ent, int colormap)
 }
 
 // note this is a recursive function, recursionlimit should be 32 or so on the initial call
-void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolate)
+static void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolate)
 {
        const matrix4x4_t *matrix;
        matrix4x4_t blendmatrix, tempmatrix, matrix2;
@@ -1195,7 +1179,7 @@ void CL_UpdateNetworkEntity(entity_t *e, int recursionlimit, qboolean interpolat
 }
 
 // creates light and trails from an entity
-void CL_UpdateNetworkEntityTrail(entity_t *e)
+static void CL_UpdateNetworkEntityTrail(entity_t *e)
 {
        effectnameindex_t trailtype;
        vec3_t origin;
@@ -1309,7 +1293,7 @@ void CL_UpdateViewEntities(void)
 CL_UpdateNetworkCollisionEntities
 ===============
 */
-void CL_UpdateNetworkCollisionEntities(void)
+static void CL_UpdateNetworkCollisionEntities(void)
 {
        entity_t *ent;
        int i;
@@ -1331,14 +1315,12 @@ void CL_UpdateNetworkCollisionEntities(void)
        }
 }
 
-extern void R_DecalSystem_Reset(decalsystem_t *decalsystem);
-
 /*
 ===============
 CL_UpdateNetworkEntities
 ===============
 */
-void CL_UpdateNetworkEntities(void)
+static void CL_UpdateNetworkEntities(void)
 {
        entity_t *ent;
        int i;
@@ -1365,7 +1347,7 @@ void CL_UpdateNetworkEntities(void)
        }
 }
 
-void CL_UpdateViewModel(void)
+static void CL_UpdateViewModel(void)
 {
        entity_t *ent;
        ent = &cl.viewent;
@@ -1400,12 +1382,13 @@ void CL_UpdateViewModel(void)
 }
 
 // note this is a recursive function, but it can never get in a runaway loop (because of the delayedlink flags)
-void CL_LinkNetworkEntity(entity_t *e)
+static void CL_LinkNetworkEntity(entity_t *e)
 {
        effectnameindex_t trailtype;
        vec3_t origin;
        vec3_t dlightcolor;
        vec_t dlightradius;
+       char vabuf[1024];
 
        // skip inactive entities and world
        if (!e->state_current.active || e == cl.entities)
@@ -1542,7 +1525,7 @@ void CL_LinkNetworkEntity(entity_t *e)
                // FIXME: add ambient/diffuse/specular scales as an extension ontop of TENEBRAE_GFX_DLIGHTS?
                Matrix4x4_Normalize(&dlightmatrix, &e->render.matrix);
                Matrix4x4_Scale(&dlightmatrix, light[3], 1);
-               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &dlightmatrix, light, e->state_current.lightstyle, e->state_current.skin > 0 ? va("cubemaps/%i", e->state_current.skin) : NULL, !(e->state_current.lightpflags & PFLAGS_NOSHADOW), (e->state_current.lightpflags & PFLAGS_CORONA) != 0, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &dlightmatrix, light, e->state_current.lightstyle, e->state_current.skin > 0 ? va(vabuf, sizeof(vabuf), "cubemaps/%i", e->state_current.skin) : NULL, !(e->state_current.lightpflags & PFLAGS_NOSHADOW), (e->state_current.lightpflags & PFLAGS_CORONA) != 0, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
        }
        // make the glow dlight
@@ -1573,7 +1556,7 @@ void CL_LinkNetworkEntity(entity_t *e)
        //      Matrix4x4_Print(&e->render.matrix);
 }
 
-void CL_RelinkWorld(void)
+static void CL_RelinkWorld(void)
 {
        entity_t *ent = &cl.entities[0];
        // FIXME: this should be done at load
@@ -1850,7 +1833,7 @@ static void CL_RelinkQWNails(void)
        }
 }
 
-void CL_LerpPlayer(float frac)
+static void CL_LerpPlayer(float frac)
 {
        int i;
 
@@ -2036,19 +2019,19 @@ static void CL_TimeRefresh_f (void)
 
        r_refdef.scene.extraupdate = false;
 
-       timestart = Sys_DoubleTime();
+       timestart = Sys_DirtyTime();
        for (i = 0;i < 128;i++)
        {
                Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], 0, i / 128.0 * 360.0, 0, 1);
                r_refdef.view.quality = 1;
                CL_UpdateScreen();
        }
-       timedelta = Sys_DoubleTime() - timestart;
+       timedelta = Sys_DirtyTime() - timestart;
 
        Con_Printf("%f seconds (%f fps)\n", timedelta, 128/timedelta);
 }
 
-void CL_AreaStats_f(void)
+static void CL_AreaStats_f(void)
 {
        World_PrintAreaStats(&cl.world, "client");
 }
@@ -2088,7 +2071,7 @@ void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point)
                dpsnprintf(buffer, buffersize, "LOC=%.0f:%.0f:%.0f", point[0], point[1], point[2]);
 }
 
-void CL_Locs_FreeNode(cl_locnode_t *node)
+static void CL_Locs_FreeNode(cl_locnode_t *node)
 {
        cl_locnode_t **pointer, **next;
        for (pointer = &cl.locnodes;*pointer;pointer = next)
@@ -2104,7 +2087,7 @@ void CL_Locs_FreeNode(cl_locnode_t *node)
        Con_Printf("CL_Locs_FreeNode: no such node! (%p)\n", (void *)node);
 }
 
-void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name)
+static void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name)
 {
        cl_locnode_t *node, **pointer;
        int namelen;
@@ -2123,7 +2106,7 @@ void CL_Locs_AddNode(vec3_t mins, vec3_t maxs, const char *name)
        *pointer = node;
 }
 
-void CL_Locs_Add_f(void)
+static void CL_Locs_Add_f(void)
 {
        vec3_t mins, maxs;
        if (Cmd_Argc() != 5 && Cmd_Argc() != 8)
@@ -2145,7 +2128,7 @@ void CL_Locs_Add_f(void)
                CL_Locs_AddNode(mins, mins, Cmd_Argv(4));
 }
 
-void CL_Locs_RemoveNearest_f(void)
+static void CL_Locs_RemoveNearest_f(void)
 {
        cl_locnode_t *loc;
        loc = CL_Locs_FindNearest(r_refdef.view.origin);
@@ -2155,13 +2138,13 @@ void CL_Locs_RemoveNearest_f(void)
                Con_Printf("no loc point or box found for your location\n");
 }
 
-void CL_Locs_Clear_f(void)
+static void CL_Locs_Clear_f(void)
 {
        while (cl.locnodes)
                CL_Locs_FreeNode(cl.locnodes);
 }
 
-void CL_Locs_Save_f(void)
+static void CL_Locs_Save_f(void)
 {
        cl_locnode_t *loc;
        qfile_t *outfile;
index dcde8eb..7ff8ead 100644 (file)
@@ -191,18 +191,15 @@ cvar_t cl_iplog_name = {CVAR_SAVE, "cl_iplog_name", "darkplaces_iplog.txt", "nam
 static qboolean QW_CL_CheckOrDownloadFile(const char *filename);
 static void QW_CL_RequestNextDownload(void);
 static void QW_CL_NextUpload(void);
-void QW_CL_StartUpload(unsigned char *data, int size);
 //static qboolean QW_CL_IsUploading(void);
 static void QW_CL_StopUpload(void);
-extern void CL_VM_UpdateIntermissionState(int intermission);
-extern qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed);
 
 /*
 ==================
 CL_ParseStartSoundPacket
 ==================
 */
-void CL_ParseStartSoundPacket(int largesoundindex)
+static void CL_ParseStartSoundPacket(int largesoundindex)
 {
        vec3_t  pos;
        int     channel, ent;
@@ -215,15 +212,15 @@ void CL_ParseStartSoundPacket(int largesoundindex)
 
        if (cls.protocol == PROTOCOL_QUAKEWORLD)
        {
-               channel = MSG_ReadShort();
+               channel = MSG_ReadShort(&cl_message);
 
                if (channel & (1<<15))
-                       volume = MSG_ReadByte ();
+                       volume = MSG_ReadByte(&cl_message);
                else
                        volume = DEFAULT_SOUND_PACKET_VOLUME;
 
                if (channel & (1<<14))
-                       attenuation = MSG_ReadByte () / 64.0;
+                       attenuation = MSG_ReadByte(&cl_message) / 64.0;
                else
                        attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
        
@@ -232,48 +229,48 @@ void CL_ParseStartSoundPacket(int largesoundindex)
                ent = (channel>>3)&1023;
                channel &= 7;
 
-               sound_num = MSG_ReadByte ();
+               sound_num = MSG_ReadByte(&cl_message);
        }
        else
        {
-               field_mask = MSG_ReadByte();
+               field_mask = MSG_ReadByte(&cl_message);
 
                if (field_mask & SND_VOLUME)
-                       volume = MSG_ReadByte ();
+                       volume = MSG_ReadByte(&cl_message);
                else
                        volume = DEFAULT_SOUND_PACKET_VOLUME;
 
                if (field_mask & SND_ATTENUATION)
-                       attenuation = MSG_ReadByte () / 64.0;
+                       attenuation = MSG_ReadByte(&cl_message) / 64.0;
                else
                        attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
 
                if (field_mask & SND_SPEEDUSHORT4000)
-                       speed = ((unsigned short)MSG_ReadShort ()) / 4000.0f;
+                       speed = ((unsigned short)MSG_ReadShort(&cl_message)) / 4000.0f;
                else
                        speed = 1.0f;
 
                if (field_mask & SND_LARGEENTITY)
                {
-                       ent = (unsigned short) MSG_ReadShort ();
-                       channel = MSG_ReadChar ();
+                       ent = (unsigned short) MSG_ReadShort(&cl_message);
+                       channel = MSG_ReadChar(&cl_message);
                }
                else
                {
-                       channel = (unsigned short) MSG_ReadShort ();
+                       channel = (unsigned short) MSG_ReadShort(&cl_message);
                        ent = channel >> 3;
                        channel &= 7;
                }
 
                if (largesoundindex || (field_mask & SND_LARGESOUND) || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3)
-                       sound_num = (unsigned short) MSG_ReadShort ();
+                       sound_num = (unsigned short) MSG_ReadShort(&cl_message);
                else
-                       sound_num = MSG_ReadByte ();
+                       sound_num = MSG_ReadByte(&cl_message);
        }
 
        channel = CHAN_NET2ENGINE(channel);
 
-       MSG_ReadVector(pos, cls.protocol);
+       MSG_ReadVector(&cl_message, pos, cls.protocol);
 
        if (sound_num >= MAX_SOUNDS)
        {
@@ -307,14 +304,12 @@ static unsigned char olddata[NET_MAXMESSAGE];
 void CL_KeepaliveMessage (qboolean readmessages)
 {
        static qboolean recursive = false;
-       float time;
+       double time;
        static double nextmsg = -1;
        static double nextupdate = -1;
 #if 0
        static double lasttime = -1;
 #endif
-       int oldreadcount;
-       qboolean oldbadread;
        sizebuf_t old;
 
        qboolean thisrecursive;
@@ -322,11 +317,12 @@ void CL_KeepaliveMessage (qboolean readmessages)
        thisrecursive = recursive;
        recursive = true;
 
+       time = Sys_DirtyTime();
        if(!thisrecursive)
        {
                if(cls.state != ca_dedicated)
                {
-                       if((time = Sys_DoubleTime()) >= nextupdate)
+                       if(time >= nextupdate || time < nextupdate) // check if time stepped backwards
                        {
                                SCR_UpdateLoadingScreenIfShown();
                                nextupdate = time + 2;
@@ -344,28 +340,16 @@ void CL_KeepaliveMessage (qboolean readmessages)
        if (readmessages)
        {
                // read messages from server, should just be nops
-               oldreadcount = msg_readcount;
-               oldbadread = msg_badread;
-               old = net_message;
-               memcpy(olddata, net_message.data, net_message.cursize);
+               old = cl_message;
+               memcpy(olddata, cl_message.data, cl_message.cursize);
 
                NetConn_ClientFrame();
 
-               msg_readcount = oldreadcount;
-               msg_badread = oldbadread;
-               net_message = old;
-               memcpy(net_message.data, olddata, net_message.cursize);
+               cl_message = old;
+               memcpy(cl_message.data, olddata, cl_message.cursize);
        }
 
-#if 0
-       if((time = Sys_DoubleTime()) >= lasttime + 1)
-       {
-               Con_Printf("long delta: %f\n", time - lasttime);
-       }
-       lasttime = Sys_DoubleTime();
-#endif
-
-       if (cls.netcon && (time = Sys_DoubleTime()) >= nextmsg)
+       if (cls.netcon && (time >= nextmsg || time < nextmsg)) // check if time stepped backwards
        {
                sizebuf_t       msg;
                unsigned char           buf[4];
@@ -462,12 +446,11 @@ void CL_ParseEntityLump(char *entdata)
        }
 }
 
-extern void CL_Locs_Reload_f(void);
-extern void CL_VM_Init (void);
 static const vec3_t defaultmins = {-4096, -4096, -4096};
 static const vec3_t defaultmaxs = {4096, 4096, 4096};
 static void CL_SetupWorldModel(void)
 {
+       prvm_prog_t *prog = CLVM_prog;
        // update the world model
        cl.entities[0].render.model = cl.worldmodel = CL_GetModelByIndex(1);
        CL_UpdateRenderEntity(&cl.entities[0].render);
@@ -483,14 +466,14 @@ static void CL_SetupWorldModel(void)
                Cvar_SetQuick(&cl_worldname, cl.worldname);
                Cvar_SetQuick(&cl_worldnamenoextension, cl.worldnamenoextension);
                Cvar_SetQuick(&cl_worldbasename, cl.worldbasename);
-               World_SetSize(&cl.world, cl.worldname, cl.worldmodel->normalmins, cl.worldmodel->normalmaxs);
+               World_SetSize(&cl.world, cl.worldname, cl.worldmodel->normalmins, cl.worldmodel->normalmaxs, prog);
        }
        else
        {
                Cvar_SetQuick(&cl_worldmessage, cl.worldmessage);
                Cvar_SetQuick(&cl_worldnamenoextension, "");
                Cvar_SetQuick(&cl_worldbasename, "");
-               World_SetSize(&cl.world, "", defaultmins, defaultmaxs);
+               World_SetSize(&cl.world, "", defaultmins, defaultmaxs, prog);
        }
        World_Start(&cl.world);
 
@@ -527,6 +510,7 @@ static void CL_SetupWorldModel(void)
 static qboolean QW_CL_CheckOrDownloadFile(const char *filename)
 {
        qfile_t *file;
+       char vabuf[1024];
 
        // see if the file already exists
        file = FS_OpenVirtualFile(filename, true);
@@ -558,7 +542,7 @@ static qboolean QW_CL_CheckOrDownloadFile(const char *filename)
        }
 
        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-       MSG_WriteString(&cls.netcon->message, va("download %s", filename));
+       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "download %s", filename));
 
        cls.qw_downloadnumber++;
        cls.qw_downloadpercent = 0;
@@ -571,6 +555,7 @@ static void QW_CL_ProcessUserInfo(int slot);
 static void QW_CL_RequestNextDownload(void)
 {
        int i;
+       char vabuf[1024];
 
        // clear name of file that just finished
        cls.qw_downloadname[0] = 0;
@@ -587,7 +572,7 @@ static void QW_CL_RequestNextDownload(void)
                        if (!cl.scores[cls.qw_downloadnumber].name[0])
                                continue;
                        // check if we need to download the file, and return if so
-                       if (!QW_CL_CheckOrDownloadFile(va("skins/%s.pcx", cl.scores[cls.qw_downloadnumber].qw_skin)))
+                       if (!QW_CL_CheckOrDownloadFile(va(vabuf, sizeof(vabuf), "skins/%s.pcx", cl.scores[cls.qw_downloadnumber].qw_skin)))
                                return;
                }
 
@@ -603,7 +588,7 @@ static void QW_CL_RequestNextDownload(void)
                        cls.signon = SIGNONS-1;
                        // we'll go to SIGNONS when the first entity update is received
                        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("begin %i", cl.qw_servercount));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "begin %i", cl.qw_servercount));
                }
                break;
        case dl_model:
@@ -668,12 +653,12 @@ static void QW_CL_RequestNextDownload(void)
                CL_SetupWorldModel();
 
                // add pmodel/emodel CRCs to userinfo
-               CL_SetInfo("pmodel", va("%i", FS_CRCFile("progs/player.mdl", NULL)), true, true, true, true);
-               CL_SetInfo("emodel", va("%i", FS_CRCFile("progs/eyes.mdl", NULL)), true, true, true, true);
+               CL_SetInfo("pmodel", va(vabuf, sizeof(vabuf), "%i", FS_CRCFile("progs/player.mdl", NULL)), true, true, true, true);
+               CL_SetInfo("emodel", va(vabuf, sizeof(vabuf), "%i", FS_CRCFile("progs/eyes.mdl", NULL)), true, true, true, true);
 
                // done checking sounds and models, send a prespawn command now
                MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-               MSG_WriteString(&cls.netcon->message, va("prespawn %i 0 %i", cl.qw_servercount, cl.model_precache[1]->brush.qw_md4sum2));
+               MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "prespawn %i 0 %i", cl.qw_servercount, cl.model_precache[1]->brush.qw_md4sum2));
 
                if (cls.qw_downloadmemory)
                {
@@ -694,7 +679,7 @@ static void QW_CL_RequestNextDownload(void)
                for (;cl.sound_name[cls.qw_downloadnumber][0];cls.qw_downloadnumber++)
                {
                        // check if we need to download the file, and return if so
-                       if (!QW_CL_CheckOrDownloadFile(va("sound/%s", cl.sound_name[cls.qw_downloadnumber])))
+                       if (!QW_CL_CheckOrDownloadFile(va(vabuf, sizeof(vabuf), "sound/%s", cl.sound_name[cls.qw_downloadnumber])))
                                return;
                }
 
@@ -724,7 +709,7 @@ static void QW_CL_RequestNextDownload(void)
 
                // done with sound downloads, next we check models
                MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-               MSG_WriteString(&cls.netcon->message, va("modellist %i %i", cl.qw_servercount, 0));
+               MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "modellist %i %i", cl.qw_servercount, 0));
                break;
        case dl_none:
        default:
@@ -734,8 +719,8 @@ static void QW_CL_RequestNextDownload(void)
 
 static void QW_CL_ParseDownload(void)
 {
-       int size = (signed short)MSG_ReadShort();
-       int percent = MSG_ReadByte();
+       int size = (signed short)MSG_ReadShort(&cl_message);
+       int percent = MSG_ReadByte(&cl_message);
 
        //Con_Printf("download %i %i%% (%i/%i)\n", size, percent, cls.qw_downloadmemorycursize, cls.qw_downloadmemorymaxsize);
 
@@ -743,7 +728,7 @@ static void QW_CL_ParseDownload(void)
        if (!cls.netcon)
        {
                if (size > 0)
-                       msg_readcount += size;
+                       cl_message.readcount += size;
                return;
        }
 
@@ -754,7 +739,7 @@ static void QW_CL_ParseDownload(void)
                return;
        }
 
-       if (msg_readcount + (unsigned short)size > net_message.cursize)
+       if (cl_message.readcount + (unsigned short)size > cl_message.cursize)
                Host_Error("corrupt download message\n");
 
        // make sure the buffer is big enough to include this new fragment
@@ -773,7 +758,7 @@ static void QW_CL_ParseDownload(void)
        }
 
        // read the fragment out of the packet
-       MSG_ReadBytes(size, cls.qw_downloadmemory + cls.qw_downloadmemorycursize);
+       MSG_ReadBytes(&cl_message, size, cls.qw_downloadmemory + cls.qw_downloadmemorycursize);
        cls.qw_downloadmemorycursize += size;
        cls.qw_downloadspeedcount += size;
 
@@ -802,13 +787,14 @@ static void QW_CL_ParseDownload(void)
 static void QW_CL_ParseModelList(void)
 {
        int n;
-       int nummodels = MSG_ReadByte();
+       int nummodels = MSG_ReadByte(&cl_message);
        char *str;
+       char vabuf[1024];
 
        // parse model precache list
        for (;;)
        {
-               str = MSG_ReadString();
+               str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                if (!str[0])
                        break;
                nummodels++;
@@ -819,11 +805,11 @@ static void QW_CL_ParseModelList(void)
                strlcpy(cl.model_name[nummodels], str, sizeof (cl.model_name[nummodels]));
        }
 
-       n = MSG_ReadByte();
+       n = MSG_ReadByte(&cl_message);
        if (n)
        {
                MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-               MSG_WriteString(&cls.netcon->message, va("modellist %i %i", cl.qw_servercount, n));
+               MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "modellist %i %i", cl.qw_servercount, n));
                return;
        }
 
@@ -836,13 +822,14 @@ static void QW_CL_ParseModelList(void)
 static void QW_CL_ParseSoundList(void)
 {
        int n;
-       int numsounds = MSG_ReadByte();
+       int numsounds = MSG_ReadByte(&cl_message);
        char *str;
+       char vabuf[1024];
 
        // parse sound precache list
        for (;;)
        {
-               str = MSG_ReadString();
+               str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                if (!str[0])
                        break;
                numsounds++;
@@ -853,12 +840,12 @@ static void QW_CL_ParseSoundList(void)
                strlcpy(cl.sound_name[numsounds], str, sizeof (cl.sound_name[numsounds]));
        }
 
-       n = MSG_ReadByte();
+       n = MSG_ReadByte(&cl_message);
 
        if (n)
        {
                MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-               MSG_WriteString(&cls.netcon->message, va("soundlist %i %i", cl.qw_servercount, n));
+               MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "soundlist %i %i", cl.qw_servercount, n));
                return;
        }
 
@@ -971,16 +958,16 @@ static void QW_CL_ProcessUserInfo(int slot)
 static void QW_CL_UpdateUserInfo(void)
 {
        int slot;
-       slot = MSG_ReadByte();
+       slot = MSG_ReadByte(&cl_message);
        if (slot >= cl.maxclients)
        {
                Con_Printf("svc_updateuserinfo >= cl.maxclients\n");
-               MSG_ReadLong();
-               MSG_ReadString();
+               MSG_ReadLong(&cl_message);
+               MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                return;
        }
-       cl.scores[slot].qw_userid = MSG_ReadLong();
-       strlcpy(cl.scores[slot].qw_userinfo, MSG_ReadString(), sizeof(cl.scores[slot].qw_userinfo));
+       cl.scores[slot].qw_userid = MSG_ReadLong(&cl_message);
+       strlcpy(cl.scores[slot].qw_userinfo, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(cl.scores[slot].qw_userinfo));
 
        QW_CL_ProcessUserInfo(slot);
 }
@@ -990,9 +977,9 @@ static void QW_CL_SetInfo(void)
        int slot;
        char key[2048];
        char value[2048];
-       slot = MSG_ReadByte();
-       strlcpy(key, MSG_ReadString(), sizeof(key));
-       strlcpy(value, MSG_ReadString(), sizeof(value));
+       slot = MSG_ReadByte(&cl_message);
+       strlcpy(key, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(key));
+       strlcpy(value, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(value));
        if (slot >= cl.maxclients)
        {
                Con_Printf("svc_setinfo >= cl.maxclients\n");
@@ -1008,8 +995,8 @@ static void QW_CL_ServerInfo(void)
        char key[2048];
        char value[2048];
        char temp[32];
-       strlcpy(key, MSG_ReadString(), sizeof(key));
-       strlcpy(value, MSG_ReadString(), sizeof(value));
+       strlcpy(key, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(key));
+       strlcpy(value, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof(value));
        Con_DPrintf("SERVERINFO: %s=%s\n", key, value);
        InfoString_SetValue(cl.qw_serverinfo, sizeof(cl.qw_serverinfo), key, value);
        InfoString_GetValue(cl.qw_serverinfo, "teamplay", temp, sizeof(temp));
@@ -1019,13 +1006,13 @@ static void QW_CL_ServerInfo(void)
 static void QW_CL_ParseNails(void)
 {
        int i, j;
-       int numnails = MSG_ReadByte();
+       int numnails = MSG_ReadByte(&cl_message);
        vec_t *v;
        unsigned char bits[6];
        for (i = 0;i < numnails;i++)
        {
                for (j = 0;j < 6;j++)
-                       bits[j] = MSG_ReadByte();
+                       bits[j] = MSG_ReadByte(&cl_message);
                if (cl.qw_num_nails > 255)
                        continue;
                v = cl.qw_nails[cl.qw_num_nails++];
@@ -1061,8 +1048,9 @@ static void CL_UpdateItemsAndWeapon(void)
 #define LOADPROGRESSWEIGHT_WORLDMODEL      30.0
 #define LOADPROGRESSWEIGHT_WORLDMODEL_INIT  2.0
 
-void CL_BeginDownloads(qboolean aborteddownload)
+static void CL_BeginDownloads(qboolean aborteddownload)
 {
+       char vabuf[1024];
        // quakeworld works differently
        if (cls.protocol == PROTOCOL_QUAKEWORLD)
                return;
@@ -1095,13 +1083,13 @@ void CL_BeginDownloads(qboolean aborteddownload)
                 && csqc_progcrc.integer >= 0
                 && cl_serverextension_download.integer
                 && (FS_CRCFile(csqc_progname.string, &progsize) != csqc_progcrc.integer || ((int)progsize != csqc_progsize.integer && csqc_progsize.integer != -1))
-                && !FS_FileExists(va("dlcache/%s.%i.%i", csqc_progname.string, csqc_progsize.integer, csqc_progcrc.integer)))
+                && !FS_FileExists(va(vabuf, sizeof(vabuf), "dlcache/%s.%i.%i", csqc_progname.string, csqc_progsize.integer, csqc_progcrc.integer)))
                {
                        Con_Printf("Downloading new CSQC code to dlcache/%s.%i.%i\n", csqc_progname.string, csqc_progsize.integer, csqc_progcrc.integer);
                        if(cl_serverextension_download.integer == 2 && FS_HasZlib())
-                               Cmd_ForwardStringToServer(va("download %s deflate", csqc_progname.string));
+                               Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "download %s deflate", csqc_progname.string));
                        else
-                               Cmd_ForwardStringToServer(va("download %s", csqc_progname.string));
+                               Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "download %s", csqc_progname.string));
                        return;
                }
        }
@@ -1269,7 +1257,7 @@ void CL_BeginDownloads(qboolean aborteddownload)
                                // regarding the * check: don't try to download submodels
                                if (cl_serverextension_download.integer && cls.netcon && cl.model_name[cl.downloadmodel_current][0] != '*' && !sv.active)
                                {
-                                       Cmd_ForwardStringToServer(va("download %s", cl.model_name[cl.downloadmodel_current]));
+                                       Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "download %s", cl.model_name[cl.downloadmodel_current]));
                                        // we'll try loading again when the download finishes
                                        return;
                                }
@@ -1322,7 +1310,7 @@ void CL_BeginDownloads(qboolean aborteddownload)
                                Con_Printf("Sound %s not found\n", soundname);
                                if (cl_serverextension_download.integer && cls.netcon && !sv.active)
                                {
-                                       Cmd_ForwardStringToServer(va("download %s", soundname));
+                                       Cmd_ForwardStringToServer(va(vabuf, sizeof(vabuf), "download %s", soundname));
                                        // we'll try loading again when the download finishes
                                        return;
                                }
@@ -1348,7 +1336,7 @@ void CL_BeginDownloads(qboolean aborteddownload)
        }
 }
 
-void CL_BeginDownloads_f(void)
+static void CL_BeginDownloads_f(void)
 {
        // prevent cl_begindownloads from being issued multiple times in one match
        // to prevent accidentally cancelled downloads
@@ -1358,7 +1346,7 @@ void CL_BeginDownloads_f(void)
                CL_BeginDownloads(false);
 }
 
-void CL_StopDownload(int size, int crc)
+static void CL_StopDownload(int size, int crc)
 {
        if (cls.qw_downloadmemory && cls.qw_downloadmemorycursize == size && CRC_Block(cls.qw_downloadmemory, cls.qw_downloadmemorycursize) == crc)
        {
@@ -1443,12 +1431,12 @@ void CL_StopDownload(int size, int crc)
        cls.qw_downloadpercent = 0;
 }
 
-void CL_ParseDownload(void)
+static void CL_ParseDownload(void)
 {
        int i, start, size;
        static unsigned char data[NET_MAXMESSAGE];
-       start = MSG_ReadLong();
-       size = (unsigned short)MSG_ReadShort();
+       start = MSG_ReadLong(&cl_message);
+       size = (unsigned short)MSG_ReadShort(&cl_message);
 
        // record the start/size information to ack in the next input packet
        for (i = 0;i < CL_MAX_DOWNLOADACKS;i++)
@@ -1461,7 +1449,7 @@ void CL_ParseDownload(void)
                }
        }
 
-       MSG_ReadBytes(size, data);
+       MSG_ReadBytes(&cl_message, size, data);
 
        if (!cls.qw_downloadname[0])
        {
@@ -1482,7 +1470,7 @@ void CL_ParseDownload(void)
        cls.qw_downloadspeedcount += size;
 }
 
-void CL_DownloadBegin_f(void)
+static void CL_DownloadBegin_f(void)
 {
        int size = atoi(Cmd_Argv(1));
 
@@ -1515,7 +1503,7 @@ void CL_DownloadBegin_f(void)
        Cmd_ForwardStringToServer("sv_startdownload");
 }
 
-void CL_StopDownload_f(void)
+static void CL_StopDownload_f(void)
 {
        Curl_CancelAll();
        if (cls.qw_downloadname[0])
@@ -1526,7 +1514,7 @@ void CL_StopDownload_f(void)
        CL_BeginDownloads(true);
 }
 
-void CL_DownloadFinished_f(void)
+static void CL_DownloadFinished_f(void)
 {
        if (Cmd_Argc() < 3)
        {
@@ -1539,29 +1527,30 @@ void CL_DownloadFinished_f(void)
 
 static void CL_SendPlayerInfo(void)
 {
+       char vabuf[1024];
        MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-       MSG_WriteString (&cls.netcon->message, va("name \"%s\"", cl_name.string));
+       MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "name \"%s\"", cl_name.string));
 
        MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-       MSG_WriteString (&cls.netcon->message, va("color %i %i", cl_color.integer >> 4, cl_color.integer & 15));
+       MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "color %i %i", cl_color.integer >> 4, cl_color.integer & 15));
 
        MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-       MSG_WriteString (&cls.netcon->message, va("rate %i", cl_rate.integer));
+       MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "rate %i", cl_rate.integer));
 
        if (cl_pmodel.integer)
        {
                MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-               MSG_WriteString (&cls.netcon->message, va("pmodel %i", cl_pmodel.integer));
+               MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "pmodel %i", cl_pmodel.integer));
        }
        if (*cl_playermodel.string)
        {
                MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-               MSG_WriteString (&cls.netcon->message, va("playermodel %s", cl_playermodel.string));
+               MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "playermodel %s", cl_playermodel.string));
        }
        if (*cl_playerskin.string)
        {
                MSG_WriteByte (&cls.netcon->message, clc_stringcmd);
-               MSG_WriteString (&cls.netcon->message, va("playerskin %s", cl_playerskin.string));
+               MSG_WriteString (&cls.netcon->message, va(vabuf, sizeof(vabuf), "playerskin %s", cl_playerskin.string));
        }
 }
 
@@ -1638,12 +1627,13 @@ static void CL_SignonReply (void)
 CL_ParseServerInfo
 ==================
 */
-void CL_ParseServerInfo (void)
+static void CL_ParseServerInfo (void)
 {
        char *str;
        int i;
        protocolversion_t protocol;
        int nummodels, numsounds;
+       char vabuf[1024];
 
        // if we start loading a level and a video is still playing, stop it
        CL_VideoStop();
@@ -1672,7 +1662,7 @@ void CL_ParseServerInfo (void)
        CL_ClearState ();
 
 // parse protocol version number
-       i = MSG_ReadLong ();
+       i = MSG_ReadLong(&cl_message);
        protocol = Protocol_EnumForNumber(i);
        if (protocol == PROTOCOL_UNKNOWN)
        {
@@ -1691,9 +1681,9 @@ void CL_ParseServerInfo (void)
        {
                char gamedir[1][MAX_QPATH];
 
-               cl.qw_servercount = MSG_ReadLong();
+               cl.qw_servercount = MSG_ReadLong(&cl_message);
 
-               str = MSG_ReadString();
+               str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                Con_Printf("server gamedir is %s\n", str);
                strlcpy(gamedir[0], str, sizeof(gamedir[0]));
 
@@ -1705,27 +1695,27 @@ void CL_ParseServerInfo (void)
                cl.maxclients = 32;
 
                // parse player number
-               i = MSG_ReadByte();
+               i = MSG_ReadByte(&cl_message);
                // cl.qw_spectator is an unneeded flag, cl.scores[cl.playerentity].qw_spectator works better (it can be updated by the server during the game)
                //cl.qw_spectator = (i & 128) != 0;
                cl.realplayerentity = cl.playerentity = cl.viewentity = (i & 127) + 1;
                cl.scores = (scoreboard_t *)Mem_Alloc(cls.levelmempool, cl.maxclients*sizeof(*cl.scores));
 
                // get the full level name
-               str = MSG_ReadString ();
+               str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                strlcpy (cl.worldmessage, str, sizeof(cl.worldmessage));
 
                // get the movevars that are defined in the qw protocol
-               cl.movevars_gravity            = MSG_ReadFloat();
-               cl.movevars_stopspeed          = MSG_ReadFloat();
-               cl.movevars_maxspeed           = MSG_ReadFloat();
-               cl.movevars_spectatormaxspeed  = MSG_ReadFloat();
-               cl.movevars_accelerate         = MSG_ReadFloat();
-               cl.movevars_airaccelerate      = MSG_ReadFloat();
-               cl.movevars_wateraccelerate    = MSG_ReadFloat();
-               cl.movevars_friction           = MSG_ReadFloat();
-               cl.movevars_waterfriction      = MSG_ReadFloat();
-               cl.movevars_entgravity         = MSG_ReadFloat();
+               cl.movevars_gravity            = MSG_ReadFloat(&cl_message);
+               cl.movevars_stopspeed          = MSG_ReadFloat(&cl_message);
+               cl.movevars_maxspeed           = MSG_ReadFloat(&cl_message);
+               cl.movevars_spectatormaxspeed  = MSG_ReadFloat(&cl_message);
+               cl.movevars_accelerate         = MSG_ReadFloat(&cl_message);
+               cl.movevars_airaccelerate      = MSG_ReadFloat(&cl_message);
+               cl.movevars_wateraccelerate    = MSG_ReadFloat(&cl_message);
+               cl.movevars_friction           = MSG_ReadFloat(&cl_message);
+               cl.movevars_waterfriction      = MSG_ReadFloat(&cl_message);
+               cl.movevars_entgravity         = MSG_ReadFloat(&cl_message);
 
                // other movevars not in the protocol...
                cl.movevars_wallfriction = 0;
@@ -1746,7 +1736,7 @@ void CL_ParseServerInfo (void)
                if (cls.netcon)
                {
                        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
-                       MSG_WriteString(&cls.netcon->message, va("soundlist %i %i", cl.qw_servercount, 0));
+                       MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "soundlist %i %i", cl.qw_servercount, 0));
                }
 
                cl.loadbegun = false;
@@ -1773,7 +1763,7 @@ void CL_ParseServerInfo (void)
        else
        {
        // parse maxclients
-               cl.maxclients = MSG_ReadByte ();
+               cl.maxclients = MSG_ReadByte(&cl_message);
                if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
                {
                        Host_Error("Bad maxclients (%u) from server", cl.maxclients);
@@ -1782,14 +1772,14 @@ void CL_ParseServerInfo (void)
                cl.scores = (scoreboard_t *)Mem_Alloc(cls.levelmempool, cl.maxclients*sizeof(*cl.scores));
 
        // parse gametype
-               cl.gametype = MSG_ReadByte ();
+               cl.gametype = MSG_ReadByte(&cl_message);
                // the original id singleplayer demos are bugged and contain
                // GAME_DEATHMATCH even for singleplayer
                if (cl.maxclients == 1 && cls.protocol == PROTOCOL_QUAKE)
                        cl.gametype = GAME_COOP;
 
        // parse signon message
-               str = MSG_ReadString ();
+               str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                strlcpy (cl.worldmessage, str, sizeof(cl.worldmessage));
 
        // seperate the printfs so the server message can have a color
@@ -1802,7 +1792,7 @@ void CL_ParseServerInfo (void)
                // parse model precache list
                for (nummodels=1 ; ; nummodels++)
                {
-                       str = MSG_ReadString();
+                       str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                        if (!str[0])
                                break;
                        if (nummodels==MAX_MODELS)
@@ -1814,7 +1804,7 @@ void CL_ParseServerInfo (void)
                // parse sound precache list
                for (numsounds=1 ; ; numsounds++)
                {
-                       str = MSG_ReadString();
+                       str = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                        if (!str[0])
                                break;
                        if (numsounds==MAX_SOUNDS)
@@ -1917,6 +1907,7 @@ void CL_ParseServerInfo (void)
                                Con_Print ("ERROR: couldn't open.\n");
                }
        }
+       cl.islocalgame = NetConn_IsLocalGame();
 }
 
 void CL_ValidateState(entity_state_t *s)
@@ -2065,7 +2056,7 @@ void CL_MoveLerpEntityStates(entity_t *ent)
 CL_ParseBaseline
 ==================
 */
-void CL_ParseBaseline (entity_t *ent, int large)
+static void CL_ParseBaseline (entity_t *ent, int large)
 {
        int i;
 
@@ -2074,25 +2065,25 @@ void CL_ParseBaseline (entity_t *ent, int large)
        ent->state_baseline.active = true;
        if (large)
        {
-               ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
-               ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
+               ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort(&cl_message);
+               ent->state_baseline.frame = (unsigned short) MSG_ReadShort(&cl_message);
        }
        else if (cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3)
        {
-               ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
-               ent->state_baseline.frame = MSG_ReadByte ();
+               ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort(&cl_message);
+               ent->state_baseline.frame = MSG_ReadByte(&cl_message);
        }
        else
        {
-               ent->state_baseline.modelindex = MSG_ReadByte ();
-               ent->state_baseline.frame = MSG_ReadByte ();
+               ent->state_baseline.modelindex = MSG_ReadByte(&cl_message);
+               ent->state_baseline.frame = MSG_ReadByte(&cl_message);
        }
-       ent->state_baseline.colormap = MSG_ReadByte();
-       ent->state_baseline.skin = MSG_ReadByte();
+       ent->state_baseline.colormap = MSG_ReadByte(&cl_message);
+       ent->state_baseline.skin = MSG_ReadByte(&cl_message);
        for (i = 0;i < 3;i++)
        {
-               ent->state_baseline.origin[i] = MSG_ReadCoord(cls.protocol);
-               ent->state_baseline.angles[i] = MSG_ReadAngle(cls.protocol);
+               ent->state_baseline.origin[i] = MSG_ReadCoord(&cl_message, cls.protocol);
+               ent->state_baseline.angles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
        }
        ent->state_previous = ent->state_current = ent->state_baseline;
 }
@@ -2105,7 +2096,7 @@ CL_ParseClientdata
 Server information pertaining to this client only
 ==================
 */
-void CL_ParseClientdata (void)
+static void CL_ParseClientdata (void)
 {
        int i, bits;
 
@@ -2132,89 +2123,89 @@ void CL_ParseClientdata (void)
        cl.mvelocity[0][2] = 0;
        cl.mviewzoom[0] = 1;
 
-       bits = (unsigned short) MSG_ReadShort ();
+       bits = (unsigned short) MSG_ReadShort(&cl_message);
        if (bits & SU_EXTEND1)
-               bits |= (MSG_ReadByte() << 16);
+               bits |= (MSG_ReadByte(&cl_message) << 16);
        if (bits & SU_EXTEND2)
-               bits |= (MSG_ReadByte() << 24);
+               bits |= (MSG_ReadByte(&cl_message) << 24);
 
        if (bits & SU_VIEWHEIGHT)
-               cl.stats[STAT_VIEWHEIGHT] = MSG_ReadChar ();
+               cl.stats[STAT_VIEWHEIGHT] = MSG_ReadChar(&cl_message);
 
        if (bits & SU_IDEALPITCH)
-               cl.idealpitch = MSG_ReadChar ();
+               cl.idealpitch = MSG_ReadChar(&cl_message);
 
        for (i = 0;i < 3;i++)
        {
                if (bits & (SU_PUNCH1<<i) )
                {
                        if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE || cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3)
-                               cl.mpunchangle[0][i] = MSG_ReadChar();
+                               cl.mpunchangle[0][i] = MSG_ReadChar(&cl_message);
                        else
-                               cl.mpunchangle[0][i] = MSG_ReadAngle16i();
+                               cl.mpunchangle[0][i] = MSG_ReadAngle16i(&cl_message);
                }
                if (bits & (SU_PUNCHVEC1<<i))
                {
                        if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3 || cls.protocol == PROTOCOL_DARKPLACES4)
-                               cl.mpunchvector[0][i] = MSG_ReadCoord16i();
+                               cl.mpunchvector[0][i] = MSG_ReadCoord16i(&cl_message);
                        else
-                               cl.mpunchvector[0][i] = MSG_ReadCoord32f();
+                               cl.mpunchvector[0][i] = MSG_ReadCoord32f(&cl_message);
                }
                if (bits & (SU_VELOCITY1<<i) )
                {
                        if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE || cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 || cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3 || cls.protocol == PROTOCOL_DARKPLACES4)
-                               cl.mvelocity[0][i] = MSG_ReadChar()*16;
+                               cl.mvelocity[0][i] = MSG_ReadChar(&cl_message)*16;
                        else
-                               cl.mvelocity[0][i] = MSG_ReadCoord32f();
+                               cl.mvelocity[0][i] = MSG_ReadCoord32f(&cl_message);
                }
        }
 
        // LordHavoc: hipnotic demos don't have this bit set but should
        if (bits & SU_ITEMS || cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE || cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 || cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5)
-               cl.stats[STAT_ITEMS] = MSG_ReadLong ();
+               cl.stats[STAT_ITEMS] = MSG_ReadLong(&cl_message);
 
        cl.onground = (bits & SU_ONGROUND) != 0;
        cl.inwater = (bits & SU_INWATER) != 0;
 
        if (cls.protocol == PROTOCOL_DARKPLACES5)
        {
-               cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadShort() : 0;
-               cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadShort() : 0;
-               cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadShort() : 0;
-               cl.stats[STAT_HEALTH] = MSG_ReadShort();
-               cl.stats[STAT_AMMO] = MSG_ReadShort();
-               cl.stats[STAT_SHELLS] = MSG_ReadShort();
-               cl.stats[STAT_NAILS] = MSG_ReadShort();
-               cl.stats[STAT_ROCKETS] = MSG_ReadShort();
-               cl.stats[STAT_CELLS] = MSG_ReadShort();
-               cl.stats[STAT_ACTIVEWEAPON] = (unsigned short) MSG_ReadShort ();
+               cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadShort(&cl_message) : 0;
+               cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadShort(&cl_message) : 0;
+               cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadShort(&cl_message) : 0;
+               cl.stats[STAT_HEALTH] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_AMMO] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_SHELLS] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_NAILS] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_ROCKETS] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_CELLS] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_ACTIVEWEAPON] = (unsigned short) MSG_ReadShort(&cl_message);
        }
        else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE || cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 || cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 || cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3 || cls.protocol == PROTOCOL_DARKPLACES4)
        {
-               cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
-               cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
+               cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte(&cl_message) : 0;
+               cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte(&cl_message) : 0;
                if (cls.protocol == PROTOCOL_NEHAHRABJP || cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3)
-                       cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? (unsigned short)MSG_ReadShort() : 0;
+                       cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? (unsigned short)MSG_ReadShort(&cl_message) : 0;
                else
-                       cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
-               cl.stats[STAT_HEALTH] = MSG_ReadShort();
-               cl.stats[STAT_AMMO] = MSG_ReadByte();
-               cl.stats[STAT_SHELLS] = MSG_ReadByte();
-               cl.stats[STAT_NAILS] = MSG_ReadByte();
-               cl.stats[STAT_ROCKETS] = MSG_ReadByte();
-               cl.stats[STAT_CELLS] = MSG_ReadByte();
+                       cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte(&cl_message) : 0;
+               cl.stats[STAT_HEALTH] = MSG_ReadShort(&cl_message);
+               cl.stats[STAT_AMMO] = MSG_ReadByte(&cl_message);
+               cl.stats[STAT_SHELLS] = MSG_ReadByte(&cl_message);
+               cl.stats[STAT_NAILS] = MSG_ReadByte(&cl_message);
+               cl.stats[STAT_ROCKETS] = MSG_ReadByte(&cl_message);
+               cl.stats[STAT_CELLS] = MSG_ReadByte(&cl_message);
                if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
-                       cl.stats[STAT_ACTIVEWEAPON] = (1<<MSG_ReadByte ());
+                       cl.stats[STAT_ACTIVEWEAPON] = (1<<MSG_ReadByte(&cl_message));
                else
-                       cl.stats[STAT_ACTIVEWEAPON] = MSG_ReadByte ();
+                       cl.stats[STAT_ACTIVEWEAPON] = MSG_ReadByte(&cl_message);
        }
 
        if (bits & SU_VIEWZOOM)
        {
                if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3 || cls.protocol == PROTOCOL_DARKPLACES4)
-                       cl.stats[STAT_VIEWZOOM] = MSG_ReadByte();
+                       cl.stats[STAT_VIEWZOOM] = MSG_ReadByte(&cl_message);
                else
-                       cl.stats[STAT_VIEWZOOM] = (unsigned short) MSG_ReadShort();
+                       cl.stats[STAT_VIEWZOOM] = (unsigned short) MSG_ReadShort(&cl_message);
        }
 
        // viewzoom interpolation
@@ -2226,7 +2217,7 @@ void CL_ParseClientdata (void)
 CL_ParseStatic
 =====================
 */
-void CL_ParseStatic (int large)
+static void CL_ParseStatic (int large)
 {
        entity_t *ent;
 
@@ -2266,46 +2257,46 @@ void CL_ParseStatic (int large)
 CL_ParseStaticSound
 ===================
 */
-void CL_ParseStaticSound (int large)
+static void CL_ParseStaticSound (int large)
 {
        vec3_t          org;
        int                     sound_num, vol, atten;
 
-       MSG_ReadVector(org, cls.protocol);
+       MSG_ReadVector(&cl_message, org, cls.protocol);
        if (large || cls.protocol == PROTOCOL_NEHAHRABJP2)
-               sound_num = (unsigned short) MSG_ReadShort ();
+               sound_num = (unsigned short) MSG_ReadShort(&cl_message);
        else
-               sound_num = MSG_ReadByte ();
-       vol = MSG_ReadByte ();
-       atten = MSG_ReadByte ();
+               sound_num = MSG_ReadByte(&cl_message);
+       vol = MSG_ReadByte(&cl_message);
+       atten = MSG_ReadByte(&cl_message);
 
        S_StaticSound (cl.sound_precache[sound_num], org, vol/255.0f, atten);
 }
 
-void CL_ParseEffect (void)
+static void CL_ParseEffect (void)
 {
        vec3_t          org;
        int                     modelindex, startframe, framecount, framerate;
 
-       MSG_ReadVector(org, cls.protocol);
-       modelindex = MSG_ReadByte ();
-       startframe = MSG_ReadByte ();
-       framecount = MSG_ReadByte ();
-       framerate = MSG_ReadByte ();
+       MSG_ReadVector(&cl_message, org, cls.protocol);
+       modelindex = MSG_ReadByte(&cl_message);
+       startframe = MSG_ReadByte(&cl_message);
+       framecount = MSG_ReadByte(&cl_message);
+       framerate = MSG_ReadByte(&cl_message);
 
        CL_Effect(org, modelindex, startframe, framecount, framerate);
 }
 
-void CL_ParseEffect2 (void)
+static void CL_ParseEffect2 (void)
 {
        vec3_t          org;
        int                     modelindex, startframe, framecount, framerate;
 
-       MSG_ReadVector(org, cls.protocol);
-       modelindex = (unsigned short) MSG_ReadShort ();
-       startframe = (unsigned short) MSG_ReadShort ();
-       framecount = MSG_ReadByte ();
-       framerate = MSG_ReadByte ();
+       MSG_ReadVector(&cl_message, org, cls.protocol);
+       modelindex = (unsigned short) MSG_ReadShort(&cl_message);
+       startframe = (unsigned short) MSG_ReadShort(&cl_message);
+       framecount = MSG_ReadByte(&cl_message);
+       framerate = MSG_ReadByte(&cl_message);
 
        CL_Effect(org, modelindex, startframe, framecount, framerate);
 }
@@ -2349,14 +2340,14 @@ void CL_NewBeam (int ent, vec3_t start, vec3_t end, dp_model_t *m, int lightning
                Con_Print("beam list overflow!\n");
 }
 
-void CL_ParseBeam (dp_model_t *m, int lightning)
+static void CL_ParseBeam (dp_model_t *m, int lightning)
 {
        int ent;
        vec3_t start, end;
 
-       ent = (unsigned short) MSG_ReadShort ();
-       MSG_ReadVector(start, cls.protocol);
-       MSG_ReadVector(end, cls.protocol);
+       ent = (unsigned short) MSG_ReadShort(&cl_message);
+       MSG_ReadVector(&cl_message, start, cls.protocol);
+       MSG_ReadVector(&cl_message, end, cls.protocol);
 
        if (ent >= MAX_EDICTS)
        {
@@ -2367,7 +2358,7 @@ void CL_ParseBeam (dp_model_t *m, int lightning)
        CL_NewBeam(ent, start, end, m, lightning);
 }
 
-void CL_ParseTempEntity(void)
+static void CL_ParseTempEntity(void)
 {
        int type;
        vec3_t pos, pos2;
@@ -2382,12 +2373,12 @@ void CL_ParseTempEntity(void)
 
        if (cls.protocol == PROTOCOL_QUAKEWORLD)
        {
-               type = MSG_ReadByte();
+               type = MSG_ReadByte(&cl_message);
                switch (type)
                {
                case QW_TE_WIZSPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_wizhit, pos, 1, 1);
@@ -2395,7 +2386,7 @@ void CL_ParseTempEntity(void)
 
                case QW_TE_KNIGHTSPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_knighthit, pos, 1, 1);
@@ -2403,7 +2394,7 @@ void CL_ParseTempEntity(void)
 
                case QW_TE_SPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2421,7 +2412,7 @@ void CL_ParseTempEntity(void)
                        break;
                case QW_TE_SUPERSPIKE:
                        // super spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2440,7 +2431,7 @@ void CL_ParseTempEntity(void)
 
                case QW_TE_EXPLOSION:
                        // rocket explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
@@ -2449,7 +2440,7 @@ void CL_ParseTempEntity(void)
 
                case QW_TE_TAREXPLOSION:
                        // tarbaby explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
@@ -2471,19 +2462,19 @@ void CL_ParseTempEntity(void)
                        break;
 
                case QW_TE_LAVASPLASH:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case QW_TE_TELEPORT:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case QW_TE_GUNSHOT:
                        // bullet hitting wall
-                       radius = MSG_ReadByte();
-                       MSG_ReadVector(pos, cls.protocol);
+                       radius = MSG_ReadByte(&cl_message);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        VectorSet(pos2, pos[0] + radius, pos[1] + radius, pos[2] + radius);
                        VectorSet(pos, pos[0] - radius, pos[1] - radius, pos[2] - radius);
@@ -2506,14 +2497,14 @@ void CL_ParseTempEntity(void)
                        break;
 
                case QW_TE_BLOOD:
-                       count = MSG_ReadByte();
-                       MSG_ReadVector(pos, cls.protocol);
+                       count = MSG_ReadByte(&cl_message);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_BLOOD, count, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case QW_TE_LIGHTNINGBLOOD:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_BLOOD, 2.5, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
@@ -2524,12 +2515,12 @@ void CL_ParseTempEntity(void)
        }
        else
        {
-               type = MSG_ReadByte();
+               type = MSG_ReadByte(&cl_message);
                switch (type)
                {
                case TE_WIZSPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_wizhit, pos, 1, 1);
@@ -2537,7 +2528,7 @@ void CL_ParseTempEntity(void)
 
                case TE_KNIGHTSPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_knighthit, pos, 1, 1);
@@ -2545,7 +2536,7 @@ void CL_ParseTempEntity(void)
 
                case TE_SPIKE:
                        // spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2563,7 +2554,7 @@ void CL_ParseTempEntity(void)
                        break;
                case TE_SPIKEQUAD:
                        // quad spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SPIKEQUAD, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2581,7 +2572,7 @@ void CL_ParseTempEntity(void)
                        break;
                case TE_SUPERSPIKE:
                        // super spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2599,7 +2590,7 @@ void CL_ParseTempEntity(void)
                        break;
                case TE_SUPERSPIKEQUAD:
                        // quad super spike hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_SUPERSPIKEQUAD, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if (rand() % 5)
@@ -2618,36 +2609,36 @@ void CL_ParseTempEntity(void)
                        // LordHavoc: added for improved blood splatters
                case TE_BLOOD:
                        // blood puff
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
-                       dir[0] = MSG_ReadChar();
-                       dir[1] = MSG_ReadChar();
-                       dir[2] = MSG_ReadChar();
-                       count = MSG_ReadByte();
+                       dir[0] = MSG_ReadChar(&cl_message);
+                       dir[1] = MSG_ReadChar(&cl_message);
+                       dir[2] = MSG_ReadChar(&cl_message);
+                       count = MSG_ReadByte(&cl_message);
                        CL_ParticleEffect(EFFECT_TE_BLOOD, count, pos, pos, dir, dir, NULL, 0);
                        break;
                case TE_SPARK:
                        // spark shower
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
-                       dir[0] = MSG_ReadChar();
-                       dir[1] = MSG_ReadChar();
-                       dir[2] = MSG_ReadChar();
-                       count = MSG_ReadByte();
+                       dir[0] = MSG_ReadChar(&cl_message);
+                       dir[1] = MSG_ReadChar(&cl_message);
+                       dir[2] = MSG_ReadChar(&cl_message);
+                       count = MSG_ReadByte(&cl_message);
                        CL_ParticleEffect(EFFECT_TE_SPARK, count, pos, pos, dir, dir, NULL, 0);
                        break;
                case TE_PLASMABURN:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_PLASMABURN, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
                        // LordHavoc: added for improved gore
                case TE_BLOODSHOWER:
                        // vaporized body
-                       MSG_ReadVector(pos, cls.protocol); // mins
-                       MSG_ReadVector(pos2, cls.protocol); // maxs
-                       velspeed = MSG_ReadCoord(cls.protocol); // speed
-                       count = (unsigned short) MSG_ReadShort(); // number of particles
+                       MSG_ReadVector(&cl_message, pos, cls.protocol); // mins
+                       MSG_ReadVector(&cl_message, pos2, cls.protocol); // maxs
+                       velspeed = MSG_ReadCoord(&cl_message, cls.protocol); // speed
+                       count = (unsigned short) MSG_ReadShort(&cl_message); // number of particles
                        vel1[0] = -velspeed;
                        vel1[1] = -velspeed;
                        vel1[2] = -velspeed;
@@ -2659,39 +2650,39 @@ void CL_ParseTempEntity(void)
 
                case TE_PARTICLECUBE:
                        // general purpose particle effect
-                       MSG_ReadVector(pos, cls.protocol); // mins
-                       MSG_ReadVector(pos2, cls.protocol); // maxs
-                       MSG_ReadVector(dir, cls.protocol); // dir
-                       count = (unsigned short) MSG_ReadShort(); // number of particles
-                       colorStart = MSG_ReadByte(); // color
-                       colorLength = MSG_ReadByte(); // gravity (1 or 0)
-                       velspeed = MSG_ReadCoord(cls.protocol); // randomvel
+                       MSG_ReadVector(&cl_message, pos, cls.protocol); // mins
+                       MSG_ReadVector(&cl_message, pos2, cls.protocol); // maxs
+                       MSG_ReadVector(&cl_message, dir, cls.protocol); // dir
+                       count = (unsigned short) MSG_ReadShort(&cl_message); // number of particles
+                       colorStart = MSG_ReadByte(&cl_message); // color
+                       colorLength = MSG_ReadByte(&cl_message); // gravity (1 or 0)
+                       velspeed = MSG_ReadCoord(&cl_message, cls.protocol); // randomvel
                        CL_ParticleCube(pos, pos2, dir, count, colorStart, colorLength != 0, velspeed);
                        break;
 
                case TE_PARTICLERAIN:
                        // general purpose particle effect
-                       MSG_ReadVector(pos, cls.protocol); // mins
-                       MSG_ReadVector(pos2, cls.protocol); // maxs
-                       MSG_ReadVector(dir, cls.protocol); // dir
-                       count = (unsigned short) MSG_ReadShort(); // number of particles
-                       colorStart = MSG_ReadByte(); // color
+                       MSG_ReadVector(&cl_message, pos, cls.protocol); // mins
+                       MSG_ReadVector(&cl_message, pos2, cls.protocol); // maxs
+                       MSG_ReadVector(&cl_message, dir, cls.protocol); // dir
+                       count = (unsigned short) MSG_ReadShort(&cl_message); // number of particles
+                       colorStart = MSG_ReadByte(&cl_message); // color
                        CL_ParticleRain(pos, pos2, dir, count, colorStart, 0);
                        break;
 
                case TE_PARTICLESNOW:
                        // general purpose particle effect
-                       MSG_ReadVector(pos, cls.protocol); // mins
-                       MSG_ReadVector(pos2, cls.protocol); // maxs
-                       MSG_ReadVector(dir, cls.protocol); // dir
-                       count = (unsigned short) MSG_ReadShort(); // number of particles
-                       colorStart = MSG_ReadByte(); // color
+                       MSG_ReadVector(&cl_message, pos, cls.protocol); // mins
+                       MSG_ReadVector(&cl_message, pos2, cls.protocol); // maxs
+                       MSG_ReadVector(&cl_message, dir, cls.protocol); // dir
+                       count = (unsigned short) MSG_ReadShort(&cl_message); // number of particles
+                       colorStart = MSG_ReadByte(&cl_message); // color
                        CL_ParticleRain(pos, pos2, dir, count, colorStart, 1);
                        break;
 
                case TE_GUNSHOT:
                        // bullet hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_GUNSHOT, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if(cl_sound_ric_gunshot.integer & RIC_GUNSHOT)
@@ -2713,7 +2704,7 @@ void CL_ParseTempEntity(void)
 
                case TE_GUNSHOTQUAD:
                        // quad bullet hitting wall
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_GUNSHOTQUAD, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        if(cl_sound_ric_gunshot.integer & RIC_GUNSHOTQUAD)
@@ -2735,7 +2726,7 @@ void CL_ParseTempEntity(void)
 
                case TE_EXPLOSION:
                        // rocket explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
@@ -2743,7 +2734,7 @@ void CL_ParseTempEntity(void)
 
                case TE_EXPLOSIONQUAD:
                        // quad rocket explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_EXPLOSIONQUAD, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
@@ -2751,11 +2742,11 @@ void CL_ParseTempEntity(void)
 
                case TE_EXPLOSION3:
                        // Nehahra movie colored lighting explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
-                       color[0] = MSG_ReadCoord(cls.protocol) * (2.0f / 1.0f);
-                       color[1] = MSG_ReadCoord(cls.protocol) * (2.0f / 1.0f);
-                       color[2] = MSG_ReadCoord(cls.protocol) * (2.0f / 1.0f);
+                       color[0] = MSG_ReadCoord(&cl_message, cls.protocol) * (2.0f / 1.0f);
+                       color[1] = MSG_ReadCoord(&cl_message, cls.protocol) * (2.0f / 1.0f);
+                       color[2] = MSG_ReadCoord(&cl_message, cls.protocol) * (2.0f / 1.0f);
                        CL_ParticleExplosion(pos);
                        Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
                        CL_AllocLightFlash(NULL, &tempmatrix, 350, color[0], color[1], color[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
@@ -2764,12 +2755,12 @@ void CL_ParseTempEntity(void)
 
                case TE_EXPLOSIONRGB:
                        // colored lighting explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleExplosion(pos);
-                       color[0] = MSG_ReadByte() * (2.0f / 255.0f);
-                       color[1] = MSG_ReadByte() * (2.0f / 255.0f);
-                       color[2] = MSG_ReadByte() * (2.0f / 255.0f);
+                       color[0] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
+                       color[1] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
+                       color[2] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
                        Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
                        CL_AllocLightFlash(NULL, &tempmatrix, 350, color[0], color[1], color[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
@@ -2777,34 +2768,34 @@ void CL_ParseTempEntity(void)
 
                case TE_TAREXPLOSION:
                        // tarbaby explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
                        break;
 
                case TE_SMALLFLASH:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_SMALLFLASH, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case TE_CUSTOMFLASH:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 4);
-                       radius = (MSG_ReadByte() + 1) * 8;
-                       velspeed = (MSG_ReadByte() + 1) * (1.0 / 256.0);
-                       color[0] = MSG_ReadByte() * (2.0f / 255.0f);
-                       color[1] = MSG_ReadByte() * (2.0f / 255.0f);
-                       color[2] = MSG_ReadByte() * (2.0f / 255.0f);
+                       radius = (MSG_ReadByte(&cl_message) + 1) * 8;
+                       velspeed = (MSG_ReadByte(&cl_message) + 1) * (1.0 / 256.0);
+                       color[0] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
+                       color[1] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
+                       color[2] = MSG_ReadByte(&cl_message) * (2.0f / 255.0f);
                        Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
                        CL_AllocLightFlash(NULL, &tempmatrix, radius, color[0], color[1], color[2], radius / velspeed, velspeed, 0, -1, true, 1, 0.25, 1, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                        break;
 
                case TE_FLAMEJET:
-                       MSG_ReadVector(pos, cls.protocol);
-                       MSG_ReadVector(dir, cls.protocol);
-                       count = MSG_ReadByte();
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, dir, cls.protocol);
+                       count = MSG_ReadByte(&cl_message);
                        CL_ParticleEffect(EFFECT_TE_FLAMEJET, count, pos, pos, dir, dir, NULL, 0);
                        break;
 
@@ -2832,25 +2823,25 @@ void CL_ParseTempEntity(void)
 
        // LordHavoc: for compatibility with the Nehahra movie...
                case TE_LIGHTNING4NEH:
-                       CL_ParseBeam(Mod_ForName(MSG_ReadString(), true, false, NULL), false);
+                       CL_ParseBeam(Mod_ForName(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), true, false, NULL), false);
                        break;
 
                case TE_LAVASPLASH:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case TE_TELEPORT:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case TE_EXPLOSION2:
                        // color mapped explosion
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
-                       colorStart = MSG_ReadByte();
-                       colorLength = MSG_ReadByte();
+                       colorStart = MSG_ReadByte(&cl_message);
+                       colorLength = MSG_ReadByte(&cl_message);
                        CL_ParticleExplosion2(pos, colorStart, colorLength);
                        tempcolor = palette_rgb[(rand()%colorLength) + colorStart];
                        color[0] = tempcolor[0] * (2.0f / 255.0f);
@@ -2862,31 +2853,31 @@ void CL_ParseTempEntity(void)
                        break;
 
                case TE_TEI_G3:
-                       MSG_ReadVector(pos, cls.protocol);
-                       MSG_ReadVector(pos2, cls.protocol);
-                       MSG_ReadVector(dir, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos2, cls.protocol);
+                       MSG_ReadVector(&cl_message, dir, cls.protocol);
                        CL_ParticleEffect(EFFECT_TE_TEI_G3, 1, pos, pos2, dir, dir, NULL, 0);
                        break;
 
                case TE_TEI_SMOKE:
-                       MSG_ReadVector(pos, cls.protocol);
-                       MSG_ReadVector(dir, cls.protocol);
-                       count = MSG_ReadByte();
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, dir, cls.protocol);
+                       count = MSG_ReadByte(&cl_message);
                        CL_FindNonSolidLocation(pos, pos, 4);
                        CL_ParticleEffect(EFFECT_TE_TEI_SMOKE, count, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
 
                case TE_TEI_BIGEXPLOSION:
-                       MSG_ReadVector(pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
                        CL_FindNonSolidLocation(pos, pos, 10);
                        CL_ParticleEffect(EFFECT_TE_TEI_BIGEXPLOSION, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        S_StartSound(-1, 0, cl.sfx_r_exp3, pos, 1, 1);
                        break;
 
                case TE_TEI_PLASMAHIT:
-                       MSG_ReadVector(pos, cls.protocol);
-                       MSG_ReadVector(dir, cls.protocol);
-                       count = MSG_ReadByte();
+                       MSG_ReadVector(&cl_message, pos, cls.protocol);
+                       MSG_ReadVector(&cl_message, dir, cls.protocol);
+                       count = MSG_ReadByte(&cl_message);
                        CL_FindNonSolidLocation(pos, pos, 5);
                        CL_ParticleEffect(EFFECT_TE_TEI_PLASMAHIT, count, pos, pos, vec3_origin, vec3_origin, NULL, 0);
                        break;
@@ -2897,39 +2888,39 @@ void CL_ParseTempEntity(void)
        }
 }
 
-void CL_ParseTrailParticles(void)
+static void CL_ParseTrailParticles(void)
 {
        int entityindex;
        int effectindex;
        vec3_t start, end;
-       entityindex = (unsigned short)MSG_ReadShort();
+       entityindex = (unsigned short)MSG_ReadShort(&cl_message);
        if (entityindex >= MAX_EDICTS)
                entityindex = 0;
        if (entityindex >= cl.max_entities)
                CL_ExpandEntities(entityindex);
-       effectindex = (unsigned short)MSG_ReadShort();
-       MSG_ReadVector(start, cls.protocol);
-       MSG_ReadVector(end, cls.protocol);
+       effectindex = (unsigned short)MSG_ReadShort(&cl_message);
+       MSG_ReadVector(&cl_message, start, cls.protocol);
+       MSG_ReadVector(&cl_message, end, cls.protocol);
        CL_ParticleEffect(effectindex, 1, start, end, vec3_origin, vec3_origin, entityindex > 0 ? cl.entities + entityindex : NULL, 0);
 }
 
-void CL_ParsePointParticles(void)
+static void CL_ParsePointParticles(void)
 {
        int effectindex, count;
        vec3_t origin, velocity;
-       effectindex = (unsigned short)MSG_ReadShort();
-       MSG_ReadVector(origin, cls.protocol);
-       MSG_ReadVector(velocity, cls.protocol);
-       count = (unsigned short)MSG_ReadShort();
+       effectindex = (unsigned short)MSG_ReadShort(&cl_message);
+       MSG_ReadVector(&cl_message, origin, cls.protocol);
+       MSG_ReadVector(&cl_message, velocity, cls.protocol);
+       count = (unsigned short)MSG_ReadShort(&cl_message);
        CL_ParticleEffect(effectindex, count, origin, origin, velocity, velocity, NULL, 0);
 }
 
-void CL_ParsePointParticles1(void)
+static void CL_ParsePointParticles1(void)
 {
        int effectindex;
        vec3_t origin;
-       effectindex = (unsigned short)MSG_ReadShort();
-       MSG_ReadVector(origin, cls.protocol);
+       effectindex = (unsigned short)MSG_ReadShort(&cl_message);
+       MSG_ReadVector(&cl_message, origin, cls.protocol);
        CL_ParticleEffect(effectindex, 1, origin, origin, vec3_origin, vec3_origin, NULL, 0);
 }
 
@@ -3083,7 +3074,7 @@ static void CL_IPLog_List_f(void)
 }
 
 // look for anything interesting like player IP addresses or ping reports
-qboolean CL_ExaminePrintString(const char *text)
+static qboolean CL_ExaminePrintString(const char *text)
 {
        int len;
        const char *t;
@@ -3228,7 +3219,6 @@ qboolean CL_ExaminePrintString(const char *text)
 
 extern cvar_t slowmo;
 extern cvar_t cl_lerpexcess;
-extern void CSQC_UpdateNetworkTimes(double newtime, double oldtime);
 static void CL_NetworkTimeReceived(double newtime)
 {
        double timehigh;
@@ -3327,14 +3317,7 @@ static void CL_NetworkTimeReceived(double newtime)
        }
 }
 
-#define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf("%3i:%s(%i)\n", msg_readcount-1, x, cmd);
-
-//[515]: csqc
-qboolean CL_VM_Parse_TempEntity (void);
-void CL_VM_Parse_StuffCmd (const char *msg);
-void CL_VM_Parse_CenterPrint (const char *msg);
-void CSQC_AddPrintText (const char *msg);
-void CSQC_ReadEntities (void);
+#define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf("%3i:%s(%i)\n", cl_message.readcount-1, x, cmd);
 
 /*
 =====================
@@ -3342,7 +3325,6 @@ CL_ParseServerMessage
 =====================
 */
 int parsingerror = false;
-extern void CL_UpdateMoveVars(void);
 void CL_ParseServerMessage(void)
 {
        int                     cmd;
@@ -3353,12 +3335,13 @@ void CL_ParseServerMessage(void)
        int                     cmdindex, cmdcount = 0;
        qboolean        qwplayerupdatereceived;
        qboolean        strip_pqc;
+       char vabuf[1024];
 
        // LordHavoc: moved demo message writing from before the packet parse to
        // after the packet parse so that CL_Stop_f can be called by cl_autodemo
        // code in CL_ParseServerinfo
        //if (cls.demorecording)
-       //      CL_WriteDemoMessage (&net_message);
+       //      CL_WriteDemoMessage (&cl_message);
 
        cl.last_received_message = realtime;
 
@@ -3368,7 +3351,7 @@ void CL_ParseServerMessage(void)
 // if recording demos, copy the message out
 //
        if (cl_shownet.integer == 1)
-               Con_Printf("%f %i\n", realtime, net_message.cursize);
+               Con_Printf("%f %i\n", realtime, cl_message.cursize);
        else if (cl_shownet.integer == 2)
                Con_Print("------------------\n");
 
@@ -3395,10 +3378,10 @@ void CL_ParseServerMessage(void)
 
                while (1)
                {
-                       if (msg_badread)
+                       if (cl_message.badread)
                                Host_Error ("CL_ParseServerMessage: Bad QW server message");
 
-                       cmd = MSG_ReadByte ();
+                       cmd = MSG_ReadByte(&cl_message);
 
                        if (cmd == -1)
                        {
@@ -3459,23 +3442,23 @@ void CL_ParseServerMessage(void)
                                return;
 
                        case qw_svc_print:
-                               i = MSG_ReadByte();
-                               temp = MSG_ReadString();
+                               i = MSG_ReadByte(&cl_message);
+                               temp = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                if (CL_ExaminePrintString(temp)) // look for anything interesting like player IP addresses or ping reports
                                {
                                        if (i == 3) // chat
-                                               CSQC_AddPrintText(va("\1%s", temp));    //[515]: csqc
+                                               CSQC_AddPrintText(va(vabuf, sizeof(vabuf), "\1%s", temp));      //[515]: csqc
                                        else
                                                CSQC_AddPrintText(temp);
                                }
                                break;
 
                        case qw_svc_centerprint:
-                               CL_VM_Parse_CenterPrint(MSG_ReadString ());     //[515]: csqc
+                               CL_VM_Parse_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));     //[515]: csqc
                                break;
 
                        case qw_svc_stufftext:
-                               CL_VM_Parse_StuffCmd(MSG_ReadString ());        //[515]: csqc
+                               CL_VM_Parse_StuffCmd(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));        //[515]: csqc
                                break;
 
                        case qw_svc_damage:
@@ -3490,7 +3473,7 @@ void CL_ParseServerMessage(void)
 
                        case qw_svc_setangle:
                                for (i=0 ; i<3 ; i++)
-                                       cl.viewangles[i] = MSG_ReadAngle (cls.protocol);
+                                       cl.viewangles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                                if (!cls.demoplayback)
                                {
                                        cl.fixangle[0] = true;
@@ -3502,13 +3485,13 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_lightstyle:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.max_lightstyle)
                                {
                                        Con_Printf ("svc_lightstyle >= MAX_LIGHTSTYLES");
                                        break;
                                }
-                               strlcpy (cl.lightstyle[i].map,  MSG_ReadString(), sizeof (cl.lightstyle[i].map));
+                               strlcpy (cl.lightstyle[i].map,  MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.lightstyle[i].map));
                                cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
                                cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
                                break;
@@ -3518,41 +3501,41 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_stopsound:
-                               i = (unsigned short) MSG_ReadShort();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                S_StopSound(i>>3, i&7);
                                break;
 
                        case qw_svc_updatefrags:
-                               i = MSG_ReadByte();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
-                               cl.scores[i].frags = (signed short) MSG_ReadShort();
+                               cl.scores[i].frags = (signed short) MSG_ReadShort(&cl_message);
                                break;
 
                        case qw_svc_updateping:
-                               i = MSG_ReadByte();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error("CL_ParseServerMessage: svc_updateping >= cl.maxclients");
-                               cl.scores[i].qw_ping = MSG_ReadShort();
+                               cl.scores[i].qw_ping = MSG_ReadShort(&cl_message);
                                break;
 
                        case qw_svc_updatepl:
-                               i = MSG_ReadByte();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error("CL_ParseServerMessage: svc_updatepl >= cl.maxclients");
-                               cl.scores[i].qw_packetloss = MSG_ReadByte();
+                               cl.scores[i].qw_packetloss = MSG_ReadByte(&cl_message);
                                break;
 
                        case qw_svc_updateentertime:
-                               i = MSG_ReadByte();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error("CL_ParseServerMessage: svc_updateentertime >= cl.maxclients");
                                // seconds ago
-                               cl.scores[i].qw_entertime = cl.time - MSG_ReadFloat();
+                               cl.scores[i].qw_entertime = cl.time - MSG_ReadFloat(&cl_message);
                                break;
 
                        case qw_svc_spawnbaseline:
-                               i = (unsigned short) MSG_ReadShort();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                if (i < 0 || i >= MAX_EDICTS)
                                        Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
                                if (i >= cl.max_entities)
@@ -3576,17 +3559,17 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_updatestat:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i < 0 || i >= MAX_CL_STATS)
                                        Host_Error ("svc_updatestat: %i is invalid", i);
-                               cl.stats[i] = MSG_ReadByte ();
+                               cl.stats[i] = MSG_ReadByte(&cl_message);
                                break;
 
                        case qw_svc_updatestatlong:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i < 0 || i >= MAX_CL_STATS)
                                        Host_Error ("svc_updatestatlong: %i is invalid", i);
-                               cl.stats[i] = MSG_ReadLong ();
+                               cl.stats[i] = MSG_ReadLong(&cl_message);
                                break;
 
                        case qw_svc_spawnstaticsound:
@@ -3594,7 +3577,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_cdtrack:
-                               cl.cdtrack = cl.looptrack = MSG_ReadByte ();
+                               cl.cdtrack = cl.looptrack = MSG_ReadByte(&cl_message);
                                if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
                                        CDAudio_Play ((unsigned char)cls.forcetrack, true);
                                else
@@ -3605,16 +3588,16 @@ void CL_ParseServerMessage(void)
                                if(!cl.intermission)
                                        cl.completed_time = cl.time;
                                cl.intermission = 1;
-                               MSG_ReadVector(cl.qw_intermission_origin, cls.protocol);
+                               MSG_ReadVector(&cl_message, cl.qw_intermission_origin, cls.protocol);
                                for (i = 0;i < 3;i++)
-                                       cl.qw_intermission_angles[i] = MSG_ReadAngle(cls.protocol);
+                                       cl.qw_intermission_angles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                                break;
 
                        case qw_svc_finale:
                                if(!cl.intermission)
                                        cl.completed_time = cl.time;
                                cl.intermission = 2;
-                               SCR_CenterPrint(MSG_ReadString ());
+                               SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                                break;
 
                        case qw_svc_sellscreen:
@@ -3629,7 +3612,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_muzzleflash:
-                               i = (unsigned short) MSG_ReadShort();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                // NOTE: in QW this only worked on clients
                                if (i < 0 || i >= MAX_EDICTS)
                                        Host_Error("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
@@ -3671,7 +3654,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_chokecount:
-                               i = MSG_ReadByte();
+                               i = MSG_ReadByte(&cl_message);
                                // FIXME: apply to netgraph
                                //for (j = 0;j < i;j++)
                                //      cl.frames[(cls.netcon->qw.incoming_acknowledged-1-j)&QW_UPDATE_MASK].receivedtime = -2;
@@ -3706,17 +3689,17 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case qw_svc_maxspeed:
-                               cl.movevars_maxspeed = MSG_ReadFloat();
+                               cl.movevars_maxspeed = MSG_ReadFloat(&cl_message);
                                break;
 
                        case qw_svc_entgravity:
-                               cl.movevars_entgravity = MSG_ReadFloat();
+                               cl.movevars_entgravity = MSG_ReadFloat(&cl_message);
                                if (!cl.movevars_entgravity)
                                        cl.movevars_entgravity = 1.0f;
                                break;
 
                        case qw_svc_setpause:
-                               cl.paused = MSG_ReadByte () != 0;
+                               cl.paused = MSG_ReadByte(&cl_message) != 0;
                                if (cl.paused)
                                        CDAudio_Pause ();
                                else
@@ -3738,10 +3721,10 @@ void CL_ParseServerMessage(void)
        {
                while (1)
                {
-                       if (msg_badread)
+                       if (cl_message.badread)
                                Host_Error ("CL_ParseServerMessage: Bad server message");
 
-                       cmd = MSG_ReadByte ();
+                       cmd = MSG_ReadByte(&cl_message);
 
                        if (cmd == -1)
                        {
@@ -3813,7 +3796,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_time:
-                               CL_NetworkTimeReceived(MSG_ReadFloat());
+                               CL_NetworkTimeReceived(MSG_ReadFloat(&cl_message));
                                break;
 
                        case svc_clientdata:
@@ -3821,7 +3804,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_version:
-                               i = MSG_ReadLong ();
+                               i = MSG_ReadLong(&cl_message);
                                protocol = Protocol_EnumForNumber(i);
                                if (protocol == PROTOCOL_UNKNOWN)
                                        Host_Error("CL_ParseServerMessage: Server is unrecognized protocol number (%i)", i);
@@ -3840,17 +3823,17 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_print:
-                               temp = MSG_ReadString();
+                               temp = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                if (CL_ExaminePrintString(temp)) // look for anything interesting like player IP addresses or ping reports
                                        CSQC_AddPrintText(temp);        //[515]: csqc
                                break;
 
                        case svc_centerprint:
-                               CL_VM_Parse_CenterPrint(MSG_ReadString ());     //[515]: csqc
+                               CL_VM_Parse_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));     //[515]: csqc
                                break;
 
                        case svc_stufftext:
-                               temp = MSG_ReadString();
+                               temp = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                /* if(utf8_enable.integer)
                                {
                                        strip_pqc = true;
@@ -3898,7 +3881,7 @@ void CL_ParseServerMessage(void)
 
                        case svc_setangle:
                                for (i=0 ; i<3 ; i++)
-                                       cl.viewangles[i] = MSG_ReadAngle (cls.protocol);
+                                       cl.viewangles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                                if (!cls.demoplayback)
                                {
                                        cl.fixangle[0] = true;
@@ -3910,7 +3893,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_setview:
-                               cl.viewentity = (unsigned short)MSG_ReadShort ();
+                               cl.viewentity = (unsigned short)MSG_ReadShort(&cl_message);
                                if (cl.viewentity >= MAX_EDICTS)
                                        Host_Error("svc_setview >= MAX_EDICTS");
                                if (cl.viewentity >= cl.max_entities)
@@ -3924,13 +3907,13 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_lightstyle:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.max_lightstyle)
                                {
                                        Con_Printf ("svc_lightstyle >= MAX_LIGHTSTYLES");
                                        break;
                                }
-                               strlcpy (cl.lightstyle[i].map,  MSG_ReadString(), sizeof (cl.lightstyle[i].map));
+                               strlcpy (cl.lightstyle[i].map,  MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.lightstyle[i].map));
                                cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
                                cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
                                break;
@@ -3947,8 +3930,8 @@ void CL_ParseServerMessage(void)
                                }
                                else
                                {
-                                       int i = (unsigned short)MSG_ReadShort();
-                                       char *s = MSG_ReadString();
+                                       int i = (unsigned short)MSG_ReadShort(&cl_message);
+                                       char *s = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                        if (i < 32768)
                                        {
                                                if (i >= 1 && i < MAX_MODELS)
@@ -3978,29 +3961,29 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_stopsound:
-                               i = (unsigned short) MSG_ReadShort();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                S_StopSound(i>>3, i&7);
                                break;
 
                        case svc_updatename:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error ("CL_ParseServerMessage: svc_updatename >= cl.maxclients");
-                               strlcpy (cl.scores[i].name, MSG_ReadString (), sizeof (cl.scores[i].name));
+                               strlcpy (cl.scores[i].name, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.scores[i].name));
                                break;
 
                        case svc_updatefrags:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error ("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
-                               cl.scores[i].frags = (signed short) MSG_ReadShort ();
+                               cl.scores[i].frags = (signed short) MSG_ReadShort(&cl_message);
                                break;
 
                        case svc_updatecolors:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i >= cl.maxclients)
                                        Host_Error ("CL_ParseServerMessage: svc_updatecolors >= cl.maxclients");
-                               cl.scores[i].colors = MSG_ReadByte ();
+                               cl.scores[i].colors = MSG_ReadByte(&cl_message);
                                break;
 
                        case svc_particle:
@@ -4016,7 +3999,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_spawnbaseline:
-                               i = (unsigned short) MSG_ReadShort ();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                if (i < 0 || i >= MAX_EDICTS)
                                        Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
                                if (i >= cl.max_entities)
@@ -4024,7 +4007,7 @@ void CL_ParseServerMessage(void)
                                CL_ParseBaseline (cl.entities + i, false);
                                break;
                        case svc_spawnbaseline2:
-                               i = (unsigned short) MSG_ReadShort ();
+                               i = (unsigned short) MSG_ReadShort(&cl_message);
                                if (i < 0 || i >= MAX_EDICTS)
                                        Host_Error ("CL_ParseServerMessage: svc_spawnbaseline2: invalid entity number %i", i);
                                if (i >= cl.max_entities)
@@ -4043,7 +4026,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_setpause:
-                               cl.paused = MSG_ReadByte () != 0;
+                               cl.paused = MSG_ReadByte(&cl_message) != 0;
                                if (cl.paused)
                                        CDAudio_Pause ();
                                else
@@ -4052,7 +4035,7 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_signonnum:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                // LordHavoc: it's rude to kick off the client if they missed the
                                // reconnect somehow, so allow signon 1 even if at signon 1
                                if (i <= cls.signon && i != 1)
@@ -4070,17 +4053,17 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_updatestat:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i < 0 || i >= MAX_CL_STATS)
                                        Host_Error ("svc_updatestat: %i is invalid", i);
-                               cl.stats[i] = MSG_ReadLong ();
+                               cl.stats[i] = MSG_ReadLong(&cl_message);
                                break;
 
                        case svc_updatestatubyte:
-                               i = MSG_ReadByte ();
+                               i = MSG_ReadByte(&cl_message);
                                if (i < 0 || i >= MAX_CL_STATS)
                                        Host_Error ("svc_updatestat: %i is invalid", i);
-                               cl.stats[i] = MSG_ReadByte ();
+                               cl.stats[i] = MSG_ReadByte(&cl_message);
                                break;
 
                        case svc_spawnstaticsound:
@@ -4092,8 +4075,8 @@ void CL_ParseServerMessage(void)
                                break;
 
                        case svc_cdtrack:
-                               cl.cdtrack = MSG_ReadByte ();
-                               cl.looptrack = MSG_ReadByte ();
+                               cl.cdtrack = MSG_ReadByte(&cl_message);
+                               cl.looptrack = MSG_ReadByte(&cl_message);
                                if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
                                        CDAudio_Play ((unsigned char)cls.forcetrack, true);
                                else
@@ -4112,7 +4095,7 @@ void CL_ParseServerMessage(void)
                                        cl.completed_time = cl.time;
                                cl.intermission = 2;
                                CL_VM_UpdateIntermissionState(cl.intermission);
-                               SCR_CenterPrint(MSG_ReadString ());
+                               SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                                break;
 
                        case svc_cutscene:
@@ -4120,7 +4103,7 @@ void CL_ParseServerMessage(void)
                                        cl.completed_time = cl.time;
                                cl.intermission = 3;
                                CL_VM_UpdateIntermissionState(cl.intermission);
-                               SCR_CenterPrint(MSG_ReadString ());
+                               SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                                break;
 
                        case svc_sellscreen:
@@ -4130,16 +4113,16 @@ void CL_ParseServerMessage(void)
                                if (gamemode == GAME_TENEBRAE)
                                {
                                        // repeating particle effect
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       (void) MSG_ReadByte();
-                                       MSG_ReadLong();
-                                       MSG_ReadLong();
-                                       MSG_ReadString();
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       (void) MSG_ReadByte(&cl_message);
+                                       MSG_ReadLong(&cl_message);
+                                       MSG_ReadLong(&cl_message);
+                                       MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                }
                                else
                                        SHOWLMP_decodehide();
@@ -4148,17 +4131,17 @@ void CL_ParseServerMessage(void)
                                if (gamemode == GAME_TENEBRAE)
                                {
                                        // particle effect
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       MSG_ReadCoord(cls.protocol);
-                                       (void) MSG_ReadByte();
-                                       MSG_ReadString();
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       MSG_ReadCoord(&cl_message, cls.protocol);
+                                       (void) MSG_ReadByte(&cl_message);
+                                       MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                                }
                                else
                                        SHOWLMP_decodeshow();
                                break;
                        case svc_skybox:
-                               R_SetSkyBox(MSG_ReadString());
+                               R_SetSkyBox(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                                break;
                        case svc_entities:
                                if (cls.signon == SIGNONS - 1)
@@ -4210,7 +4193,7 @@ void CL_ParseServerMessage(void)
        // implemented
        if (cls.demorecording)
        {
-               CL_WriteDemoMessage (&net_message);
+               CL_WriteDemoMessage (&cl_message);
 //             R_TimeReport("WriteDemo");
        }
 }
@@ -4220,7 +4203,7 @@ void CL_Parse_DumpPacket(void)
        if (!parsingerror)
                return;
        Con_Print("Packet dump:\n");
-       SZ_HexDumpToConsole(&net_message);
+       SZ_HexDumpToConsole(&cl_message);
        parsingerror = false;
 }
 
index 3bf86bd..70e1b29 100644 (file)
@@ -302,7 +302,7 @@ cvar_t cl_decals_bias = {CVAR_SAVE, "cl_decals_bias", "0.125", "distance to bias
 cvar_t cl_decals_max = {CVAR_SAVE, "cl_decals_max", "4096", "maximum number of decals allowed to exist in the world at once"};
 
 
-void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend, const char *filename)
+static void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend, const char *filename)
 {
        int arrayindex;
        int argc;
@@ -509,7 +509,7 @@ static const char *standardeffectnames[EFFECT_TOTAL] =
        "SVC_PARTICLE"
 };
 
-void CL_Particles_LoadEffectInfo(void)
+static void CL_Particles_LoadEffectInfo(void)
 {
        int i;
        int filepass;
@@ -891,7 +891,7 @@ void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size,
 
 static void CL_Sparks(const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, float sparkcount);
 static void CL_Smoke(const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, float smokecount);
-void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles)
+static void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles)
 {
        vec3_t center;
        matrix4x4_t tempmatrix;
@@ -1417,6 +1417,7 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
 void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles, float tintmins[4], float tintmaxs[4])
 {
        qboolean found = false;
+       char vabuf[1024];
        if (effectnameindex < 1 || effectnameindex >= MAX_PARTICLEEFFECTNAME || !particleeffectname[effectnameindex][0])
        {
                Con_DPrintf("Unknown effect number %i received from server\n", effectnameindex);
@@ -1485,7 +1486,7 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
                                                rvec[0] = info->lightcolor[0]*avgtint[0]*avgtint[3];
                                                rvec[1] = info->lightcolor[1]*avgtint[1]*avgtint[3];
                                                rvec[2] = info->lightcolor[2]*avgtint[2]*avgtint[3];
-                                               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &tempmatrix, rvec, -1, info->lightcubemapnum > 0 ? va("cubemaps/%i", info->lightcubemapnum) : NULL, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                                               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &tempmatrix, rvec, -1, info->lightcubemapnum > 0 ? va(vabuf, sizeof(vabuf), "cubemaps/%i", info->lightcubemapnum) : NULL, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                                                r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
                                        }
                                }
@@ -1687,11 +1688,11 @@ void CL_ParseParticleEffect (void)
        vec3_t org, dir;
        int i, count, msgcount, color;
 
-       MSG_ReadVector(org, cls.protocol);
+       MSG_ReadVector(&cl_message, org, cls.protocol);
        for (i=0 ; i<3 ; i++)
-               dir[i] = MSG_ReadChar () * (1.0 / 16.0);
-       msgcount = MSG_ReadByte ();
-       color = MSG_ReadByte ();
+               dir[i] = MSG_ReadChar(&cl_message) * (1.0 / 16.0);
+       msgcount = MSG_ReadByte(&cl_message);
+       color = MSG_ReadByte(&cl_message);
 
        if (msgcount == 255)
                count = 1024;
@@ -1930,7 +1931,7 @@ static unsigned char shadebubble(float dx, float dy, vec3_t light)
 }
 
 int particlefontwidth, particlefontheight, particlefontcellwidth, particlefontcellheight, particlefontrows, particlefontcols;
-void CL_Particle_PixelCoordsForTexnum(int texnum, int *basex, int *basey, int *width, int *height)
+static void CL_Particle_PixelCoordsForTexnum(int texnum, int *basex, int *basey, int *width, int *height)
 {
        *basex = (texnum % particlefontcols) * particlefontcellwidth;
        *basey = ((texnum / particlefontcols) % particlefontrows) * particlefontcellheight;
@@ -1948,7 +1949,7 @@ static void setuptex(int texnum, unsigned char *data, unsigned char *particletex
                memcpy(particletexturedata + ((basey + y) * PARTICLEFONTSIZE + basex) * 4, data + y * PARTICLETEXTURESIZE * 4, PARTICLETEXTURESIZE * 4);
 }
 
-void particletextureblotch(unsigned char *data, float radius, float red, float green, float blue, float alpha)
+static void particletextureblotch(unsigned char *data, float radius, float red, float green, float blue, float alpha)
 {
        int x, y;
        float cx, cy, dx, dy, f, iradius;
@@ -1977,7 +1978,8 @@ void particletextureblotch(unsigned char *data, float radius, float red, float g
        }
 }
 
-void particletextureclamp(unsigned char *data, int minr, int ming, int minb, int maxr, int maxg, int maxb)
+#if 0
+static void particletextureclamp(unsigned char *data, int minr, int ming, int minb, int maxr, int maxg, int maxb)
 {
        int i;
        for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
@@ -1987,8 +1989,9 @@ void particletextureclamp(unsigned char *data, int minr, int ming, int minb, int
                data[2] = bound(minr, data[2], maxr);
        }
 }
+#endif
 
-void particletextureinvert(unsigned char *data)
+static void particletextureinvert(unsigned char *data)
 {
        int i;
        for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
@@ -2368,7 +2371,7 @@ void R_Particles_Init (void)
        R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap, NULL, NULL);
 }
 
-void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+static void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
 {
        int surfacelistindex;
        const decal_t *d;
@@ -2519,7 +2522,7 @@ killdecal:
        r_refdef.stats.totaldecals = cl.num_decals;
 }
 
-void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+static void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
 {
        int surfacelistindex;
        int batchstart, batchcount;
index bf3749a..2c62af0 100644 (file)
@@ -143,7 +143,7 @@ void SCR_CenterPrint(const char *str)
 }
 
 
-void SCR_DrawCenterString (void)
+static void SCR_DrawCenterString (void)
 {
        char    *start;
        int             x, y;
@@ -200,7 +200,7 @@ void SCR_DrawCenterString (void)
        } while (1);
 }
 
-void SCR_CheckDrawCenterString (void)
+static void SCR_CheckDrawCenterString (void)
 {
        if (scr_center_lines > scr_erase_lines)
                scr_erase_lines = scr_center_lines;
@@ -220,7 +220,7 @@ void SCR_CheckDrawCenterString (void)
        SCR_DrawCenterString ();
 }
 
-void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int graphheight, float graphscale, const char *label, float textsize, int packetcounter, netgraphitem_t *netgraph)
+static void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int graphheight, float graphscale, const char *label, float textsize, int packetcounter, netgraphitem_t *netgraph)
 {
        netgraphitem_t *graph;
        int j, x, y, numlines;
@@ -308,11 +308,12 @@ void SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int gra
 SCR_DrawNetGraph
 ==============
 */
-void SCR_DrawNetGraph (void)
+static void SCR_DrawNetGraph (void)
 {
        int i, separator1, separator2, graphwidth, graphheight, netgraph_x, netgraph_y, textsize, index, netgraphsperrow;
        float graphscale;
        netconn_t *c;
+       char vabuf[1024];
 
        if (cls.state != ca_connected)
                return;
@@ -348,7 +349,7 @@ void SCR_DrawNetGraph (void)
                                continue;
                        netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (graphwidth * 2 + separator1 + separator2);
                        netgraph_y = (vid_conheight.integer - 48 + separator2) - (1 + (index / netgraphsperrow)) * (graphheight + textsize + separator2);
-                       SCR_DrawNetGraph_DrawGraph(netgraph_x                          , netgraph_y, graphwidth, graphheight, graphscale, va("%s", svs.clients[i].name), textsize, c->outgoing_packetcounter, c->outgoing_netgraph);
+                       SCR_DrawNetGraph_DrawGraph(netgraph_x                          , netgraph_y, graphwidth, graphheight, graphscale, va(vabuf, sizeof(vabuf), "%s", svs.clients[i].name), textsize, c->outgoing_packetcounter, c->outgoing_netgraph);
                        SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, ""                           , textsize, c->incoming_packetcounter, c->incoming_netgraph);
                        index++;
                }
@@ -360,7 +361,7 @@ void SCR_DrawNetGraph (void)
 SCR_DrawTurtle
 ==============
 */
-void SCR_DrawTurtle (void)
+static void SCR_DrawTurtle (void)
 {
        static int      count;
 
@@ -388,7 +389,7 @@ void SCR_DrawTurtle (void)
 SCR_DrawNet
 ==============
 */
-void SCR_DrawNet (void)
+static void SCR_DrawNet (void)
 {
        if (cls.state != ca_connected)
                return;
@@ -405,7 +406,7 @@ void SCR_DrawNet (void)
 DrawPause
 ==============
 */
-void SCR_DrawPause (void)
+static void SCR_DrawPause (void)
 {
        cachepic_t      *pic;
 
@@ -427,7 +428,7 @@ void SCR_DrawPause (void)
 SCR_DrawBrand
 ==============
 */
-void SCR_DrawBrand (void)
+static void SCR_DrawBrand (void)
 {
        cachepic_t      *pic;
        float           x, y;
@@ -549,9 +550,10 @@ static int SCR_DrawCurlDownload(int offset)
        float size = scr_infobar_height.value;
        Curl_downloadinfo_t *downinfo;
        char temp[256];
+       char addinfobuf[128];
        const char *addinfo;
 
-       downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo);
+       downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));
        if(!downinfo)
                return 0;
 
@@ -606,6 +608,7 @@ static int SCR_InfobarHeight(void)
        Curl_downloadinfo_t *downinfo;
        const char *addinfo;
        int nDownloads;
+       char addinfobuf[128];
 
        if (cl.time > cl.oldtime)
                scr_infobartime_off -= cl.time - cl.oldtime;
@@ -614,7 +617,7 @@ static int SCR_InfobarHeight(void)
        if(cls.qw_downloadname[0])
                offset += 1;
 
-       downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo);
+       downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));
        if(downinfo)
        {
                offset += (nDownloads + (addinfo ? 1 : 0));
@@ -630,7 +633,7 @@ static int SCR_InfobarHeight(void)
 SCR_InfoBar_f
 ==============
 */
-void SCR_InfoBar_f(void)
+static void SCR_InfoBar_f(void)
 {
        if(Cmd_Argc() == 3)
        {
@@ -649,7 +652,7 @@ void SCR_InfoBar_f(void)
 SCR_SetUpToDrawConsole
 ==================
 */
-void SCR_SetUpToDrawConsole (void)
+static void SCR_SetUpToDrawConsole (void)
 {
        // lines of console to display
        float conlines;
@@ -736,7 +739,7 @@ void R_TimeReport(const char *desc)
                GL_Finish();
        CHECKGLERROR
        r_timereport_temp = r_timereport_current;
-       r_timereport_current = Sys_DoubleTime();
+       r_timereport_current = Sys_DirtyTime();
        t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0 + 0.5);
 
        length = dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
@@ -756,7 +759,7 @@ void R_TimeReport(const char *desc)
        speedstringcount += length;
 }
 
-void R_TimeReport_BeginFrame(void)
+static void R_TimeReport_BeginFrame(void)
 {
        speedstringcount = 0;
        r_speeds_timestring[0] = 0;
@@ -766,7 +769,7 @@ void R_TimeReport_BeginFrame(void)
        if (r_speeds.integer >= 2)
        {
                r_timereport_active = true;
-               r_timereport_start = r_timereport_current = Sys_DoubleTime();
+               r_timereport_start = r_timereport_current = Sys_DirtyTime();
        }
 }
 
@@ -780,7 +783,7 @@ static int R_CountLeafTriangles(const dp_model_t *model, const mleaf_t *leaf)
 
 extern cvar_t r_viewscale;
 extern float viewscalefpsadjusted;
-void R_TimeReport_EndFrame(void)
+static void R_TimeReport_EndFrame(void)
 {
        int i, j, lines, y;
        cl_locnode_t *loc;
@@ -829,7 +832,7 @@ void R_TimeReport_EndFrame(void)
                if (r_speeds.integer >= 2)
                {
                        r_timereport_active = true;
-                       r_timereport_start = r_timereport_current = Sys_DoubleTime();
+                       r_timereport_start = r_timereport_current = Sys_DirtyTime();
                }
        }
 
@@ -867,7 +870,7 @@ SCR_SizeUp_f
 Keybinding command
 =================
 */
-void SCR_SizeUp_f (void)
+static void SCR_SizeUp_f (void)
 {
        Cvar_SetValue ("viewsize",scr_viewsize.value+10);
 }
@@ -880,7 +883,7 @@ SCR_SizeDown_f
 Keybinding command
 =================
 */
-void SCR_SizeDown_f (void)
+static void SCR_SizeDown_f (void)
 {
        Cvar_SetValue ("viewsize",scr_viewsize.value-10);
 }
@@ -990,6 +993,7 @@ void SCR_ScreenShot_f (void)
        unsigned char *buffer2;
        qboolean jpeg = (scr_screenshot_jpeg.integer != 0);
        qboolean png = (scr_screenshot_png.integer != 0) && !jpeg;
+       char vabuf[1024];
 
        if (Cmd_Argc() == 2)
        {
@@ -1029,9 +1033,9 @@ void SCR_ScreenShot_f (void)
 
                // find a file name to save it to
                for (shotnumber100 = 0;shotnumber100 < 100;shotnumber100++)
-                       if (!FS_SysFileExists(va("%s/screenshots/%s-%02d.tga", fs_gamedir, prefix_name, shotnumber100))
-                        && !FS_SysFileExists(va("%s/screenshots/%s-%02d.jpg", fs_gamedir, prefix_name, shotnumber100))
-                        && !FS_SysFileExists(va("%s/screenshots/%s-%02d.png", fs_gamedir, prefix_name, shotnumber100)))
+                       if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.tga", fs_gamedir, prefix_name, shotnumber100))
+                        && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.jpg", fs_gamedir, prefix_name, shotnumber100))
+                        && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.png", fs_gamedir, prefix_name, shotnumber100)))
                                break;
                if (shotnumber100 >= 100)
                {
@@ -1060,9 +1064,9 @@ void SCR_ScreenShot_f (void)
 
                // find a file name to save it to
                for (;shotnumber < 1000000;shotnumber++)
-                       if (!FS_SysFileExists(va("%s/screenshots/%s%06d.tga", fs_gamedir, prefix_name, shotnumber))
-                        && !FS_SysFileExists(va("%s/screenshots/%s%06d.jpg", fs_gamedir, prefix_name, shotnumber))
-                        && !FS_SysFileExists(va("%s/screenshots/%s%06d.png", fs_gamedir, prefix_name, shotnumber)))
+                       if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.tga", fs_gamedir, prefix_name, shotnumber))
+                        && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.jpg", fs_gamedir, prefix_name, shotnumber))
+                        && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.png", fs_gamedir, prefix_name, shotnumber)))
                                break;
                if (shotnumber >= 1000000)
                {
@@ -1097,7 +1101,7 @@ void SCR_ScreenShot_f (void)
        Mem_Free (buffer2);
 }
 
-void SCR_CaptureVideo_BeginVideo(void)
+static void SCR_CaptureVideo_BeginVideo(void)
 {
        double r, g, b;
        unsigned int i;
@@ -1132,7 +1136,7 @@ void SCR_CaptureVideo_BeginVideo(void)
        cls.capturevideo.soundchannels = S_GetSoundChannels();
        cls.capturevideo.startrealtime = realtime;
        cls.capturevideo.frame = cls.capturevideo.lastfpsframe = 0;
-       cls.capturevideo.starttime = cls.capturevideo.lastfpstime = Sys_DoubleTime();
+       cls.capturevideo.starttime = cls.capturevideo.lastfpstime = realtime;
        cls.capturevideo.soundsampleframe = 0;
        cls.capturevideo.realtime = cl_capturevideo_realtime.integer != 0;
        cls.capturevideo.screenbuffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 4);
@@ -1290,7 +1294,7 @@ static void SCR_ScaleDownBGRA(unsigned char *in, int inw, int inh, unsigned char
        }
 }
 
-void SCR_CaptureVideo_VideoFrame(int newframestepframenum)
+static void SCR_CaptureVideo_VideoFrame(int newframestepframenum)
 {
        int x = 0, y = 0;
        int width = cls.capturevideo.width, height = cls.capturevideo.height;
@@ -1311,7 +1315,7 @@ void SCR_CaptureVideo_VideoFrame(int newframestepframenum)
        if(cl_capturevideo_printfps.integer)
        {
                char buf[80];
-               double t = Sys_DoubleTime();
+               double t = realtime;
                if(t > cls.capturevideo.lastfpstime + 1)
                {
                        double fps1 = (cls.capturevideo.frame - cls.capturevideo.lastfpsframe) / (t - cls.capturevideo.lastfpstime + 0.0000001);
@@ -1330,7 +1334,7 @@ void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size
        cls.capturevideo.soundframe(paintbuffer, length);
 }
 
-void SCR_CaptureVideo(void)
+static void SCR_CaptureVideo(void)
 {
        int newframenum;
        if (cl_capturevideo.integer)
@@ -1475,7 +1479,7 @@ void SHOWLMP_decodehide(void)
 {
        int i;
        char *lmplabel;
-       lmplabel = MSG_ReadString();
+       lmplabel = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
        for (i = 0;i < cl.num_showlmps;i++)
                if (cl.showlmps[i].isactive && strcmp(cl.showlmps[i].label, lmplabel) == 0)
                {
@@ -1489,17 +1493,17 @@ void SHOWLMP_decodeshow(void)
        int k;
        char lmplabel[256], picname[256];
        float x, y;
-       strlcpy (lmplabel,MSG_ReadString(), sizeof (lmplabel));
-       strlcpy (picname, MSG_ReadString(), sizeof (picname));
+       strlcpy (lmplabel,MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (lmplabel));
+       strlcpy (picname, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (picname));
        if (gamemode == GAME_NEHAHRA) // LordHavoc: nasty old legacy junk
        {
-               x = MSG_ReadByte();
-               y = MSG_ReadByte();
+               x = MSG_ReadByte(&cl_message);
+               y = MSG_ReadByte(&cl_message);
        }
        else
        {
-               x = MSG_ReadShort();
-               y = MSG_ReadShort();
+               x = MSG_ReadShort(&cl_message);
+               y = MSG_ReadShort(&cl_message);
        }
        if (!cl.showlmps || cl.num_showlmps >= cl.max_showlmps)
        {
@@ -1637,7 +1641,6 @@ static void SCR_DrawTouchscreenOverlay(void)
        }
 }
 
-extern void R_UpdateFog(void);
 void R_ClearScreen(qboolean fogcolor)
 {
        float clearcolor[4];
@@ -1656,14 +1659,9 @@ void R_ClearScreen(qboolean fogcolor)
        GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | (vid.stencil ? GL_STENCIL_BUFFER_BIT : 0), clearcolor, 1.0f, 128);
 }
 
-qboolean CL_VM_UpdateView (void);
-void SCR_DrawConsole (void);
-void R_Shadow_EditLights_DrawSelectedLightProperties(void);
-
 int r_stereo_side;
 
-extern void Sbar_ShowFPS(void);
-void SCR_DrawScreen (void)
+static void SCR_DrawScreen (void)
 {
        Draw_Frame();
 
@@ -2031,6 +2029,7 @@ static void SCR_DrawLoadingScreen_SharedSetup (qboolean clear)
 {
        r_viewport_t viewport;
        float x, y, w, h, sw, sh, f;
+       char vabuf[1024];
        // release mouse grab while loading
        if (!vid.fullscreen)
                VID_SetMouse(false, false, false);
@@ -2047,7 +2046,7 @@ static void SCR_DrawLoadingScreen_SharedSetup (qboolean clear)
        R_Mesh_Start();
        R_EntityMatrix(&identitymatrix);
        // draw the loading plaque
-       loadingscreenpic = Draw_CachePic_Flags (loadingscreenpic_number ? va("gfx/loading%d", loadingscreenpic_number+1) : "gfx/loading", loadingscreenpic_number ? CACHEPICFLAG_NOTPERSISTENT : 0);
+       loadingscreenpic = Draw_CachePic_Flags (loadingscreenpic_number ? va(vabuf, sizeof(vabuf), "gfx/loading%d", loadingscreenpic_number+1) : "gfx/loading", loadingscreenpic_number ? CACHEPICFLAG_NOTPERSISTENT : 0);
 
        w = loadingscreenpic->width;
        h = loadingscreenpic->height;
@@ -2211,7 +2210,6 @@ extern cvar_t cl_minfps_qualityscale;
 extern cvar_t r_viewscale_fpsscaling;
 static double cl_updatescreen_rendertime = 0;
 static double cl_updatescreen_quality = 1;
-extern void Sbar_ShowFPS_Update(void);
 void CL_UpdateScreen(void)
 {
        vec3_t vieworigin;
@@ -2247,7 +2245,7 @@ void CL_UpdateScreen(void)
                return;
        }
 
-       rendertime1 = Sys_DoubleTime();
+       rendertime1 = Sys_DirtyTime();
 
        conwidth = bound(160, vid_conwidth.value, 32768);
        conheight = bound(90, vid_conheight.value, 24576);
@@ -2351,7 +2349,7 @@ void CL_UpdateScreen(void)
 
        if (r_viewscale_fpsscaling.integer)
                GL_Finish();
-       drawscreenstart = Sys_DoubleTime();
+       drawscreenstart = Sys_DirtyTime();
 #ifndef USE_GLES2
        if (R_Stereo_Active())
        {
@@ -2388,7 +2386,7 @@ void CL_UpdateScreen(void)
                SCR_DrawScreen();
        if (r_viewscale_fpsscaling.integer)
                GL_Finish();
-       r_refdef.lastdrawscreentime = Sys_DoubleTime() - drawscreenstart;
+       r_refdef.lastdrawscreentime = Sys_DirtyTime() - drawscreenstart;
 
        SCR_CaptureVideo();
 
@@ -2396,7 +2394,7 @@ void CL_UpdateScreen(void)
                qglFlush(); // FIXME: should we really be using qglFlush here?
 
        // quality adjustment according to render time
-       cl_updatescreen_rendertime += ((Sys_DoubleTime() - rendertime1) - cl_updatescreen_rendertime) * bound(0, cl_minfps_fade.value, 1);
+       cl_updatescreen_rendertime += ((Sys_DirtyTime() - rendertime1) - cl_updatescreen_rendertime) * bound(0, cl_minfps_fade.value, 1);
        if (cl_minfps.value > 0 && cl_updatescreen_rendertime > 0 && !cls.timedemo && (!cls.capturevideo.active || !cls.capturevideo.realtime))
                cl_updatescreen_quality = 1 / (cl_updatescreen_rendertime * cl_minfps.value);
        else
index 7c4b2a5..08db058 100644 (file)
@@ -418,7 +418,7 @@ typedef struct
 }
 cl_video_subtitle_info_t;
 
-float CL_DrawVideo_WordWidthFunc(void *passthrough, const char *w, size_t *length, float maxWidth)
+static float CL_DrawVideo_WordWidthFunc(void *passthrough, const char *w, size_t *length, float maxWidth)
 {
        cl_video_subtitle_info_t *si = (cl_video_subtitle_info_t *) passthrough;
 
@@ -432,7 +432,7 @@ float CL_DrawVideo_WordWidthFunc(void *passthrough, const char *w, size_t *lengt
                return 0;
 }
 
-int CL_DrawVideo_DisplaySubtitleLine(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
+static int CL_DrawVideo_DisplaySubtitleLine(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
 {
        cl_video_subtitle_info_t *si = (cl_video_subtitle_info_t *) passthrough;
 
@@ -577,12 +577,13 @@ void CL_DrawVideo(void)
 
 void CL_VideoStart(char *filename, const char *subtitlesfile)
 {
+       char vabuf[1024];
        Host_StartVideo();
 
        if( cl_videos->state != CLVIDEO_UNUSED )
                CL_CloseVideo( cl_videos );
        // already contains video/
-       if( !OpenVideo( cl_videos, filename, va( CLDYNTEXTUREPREFIX "%s", filename ), 0, subtitlesfile ) )
+       if( !OpenVideo( cl_videos, filename, va(vabuf, sizeof(vabuf),  CLDYNTEXTUREPREFIX "%s", filename ), 0, subtitlesfile ) )
                return;
        // expand the active range to include the new entry
        cl_num_videos = max(cl_num_videos, 1);
index a652dbc..da65ef2 100644 (file)
@@ -41,7 +41,7 @@ unsigned int jam_getwidth(void *stream);
 unsigned int jam_getheight(void *stream);
 double jam_getframerate(void *stream);
 int jam_video(void *stream, void *imagedata, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel, int imagebytesperrow);
-void *jam_open(clvideo_t *video, char *filename, const char **errorstring)
+static void *jam_open(clvideo_t *video, char *filename, const char **errorstring)
 {
        unsigned char jamHead[16];
        char *wavename;
@@ -176,7 +176,7 @@ double jam_getframerate(void *stream)
 
 
 // decode JAM frame
-void jam_decodeframe(unsigned char *inbuf, unsigned char *outbuf, unsigned char *prevbuf, int outsize, int frametype)
+static void jam_decodeframe(unsigned char *inbuf, unsigned char *outbuf, unsigned char *prevbuf, int outsize, int frametype)
 {
        unsigned char *srcptr, *destptr, *prevptr;
        int bytesleft;
index f8acbcd..cd780e6 100644 (file)
--- a/client.h
+++ b/client.h
@@ -580,7 +580,7 @@ typedef struct capturevideostate_s
        const char *formatextension;
        qfile_t *videofile;
                // always use this:
-               //   cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
+               //   cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
        void (*endvideo) (void);
        void (*videoframes) (int num);
        void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
@@ -1409,7 +1409,7 @@ extern int cl_ignoremousemoves;
 
 
 float CL_KeyState (kbutton_t *key);
-const char *Key_KeynumToString (int keynum);
+const char *Key_KeynumToString (int keynum, char *buf, size_t buflength);
 int Key_StringToKeynum (const char *str);
 
 //
@@ -1838,5 +1838,21 @@ extern r_refdef_t r_refdef;
 // warpzone prediction hack (CSQC builtin)
 void CL_RotateMoves(const matrix4x4_t *m);
 
+void CL_NewFrameReceived(int num);
+void CL_ParseEntityLump(char *entitystring);
+void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
+void CL_RelinkLightFlashes(void);
+void Sbar_ShowFPS(void);
+void Sbar_ShowFPS_Update(void);
+void Host_SaveConfig(void);
+void Host_LoadConfig_f(void);
+void CL_UpdateMoveVars(void);
+void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
+void V_DriftPitch(void);
+void V_FadeViewFlashs(void);
+void V_CalcViewBlend(void);
+void V_CalcRefdef(void);
+void CL_Locs_Reload_f(void);
+
 #endif
 
index a9c30b4..62b84db 100644 (file)
@@ -25,22 +25,15 @@ extern cvar_t r_equalize_entities_fullbright;
 
 r_refdef_view_t csqc_original_r_refdef_view;
 
-sfx_t *S_FindName(const char *name);
-int Sbar_GetSortedPlayerIndex (int index);
-void Sbar_SortFrags (void);
-void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
-void CSQC_RelinkAllEntities (int drawmask);
-void CSQC_RelinkCSQCEntities (void);
-
 // #1 void(vector ang) makevectors
-static void VM_CL_makevectors (void)
+static void VM_CL_makevectors (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
        AngleVectors (PRVM_G_VECTOR(OFS_PARM0), PRVM_clientglobalvector(v_forward), PRVM_clientglobalvector(v_right), PRVM_clientglobalvector(v_up));
 }
 
 // #2 void(entity e, vector o) setorigin
-void VM_CL_setorigin (void)
+static void VM_CL_setorigin (prvm_prog_t *prog)
 {
        prvm_edict_t    *e;
        float   *org;
@@ -49,12 +42,12 @@ void VM_CL_setorigin (void)
        e = PRVM_G_EDICT(OFS_PARM0);
        if (e == prog->edicts)
        {
-               VM_Warning("setorigin: can not modify world entity\n");
+               VM_Warning(prog, "setorigin: can not modify world entity\n");
                return;
        }
        if (e->priv.required->free)
        {
-               VM_Warning("setorigin: can not modify free entity\n");
+               VM_Warning(prog, "setorigin: can not modify free entity\n");
                return;
        }
        org = PRVM_G_VECTOR(OFS_PARM1);
@@ -62,13 +55,13 @@ void VM_CL_setorigin (void)
        CL_LinkEdict(e);
 }
 
-static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
+static void SetMinMaxSize (prvm_prog_t *prog, prvm_edict_t *e, float *min, float *max)
 {
        int             i;
 
        for (i=0 ; i<3 ; i++)
                if (min[i] > max[i])
-                       PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
+                       prog->error_cmd("SetMinMaxSize: backwards mins/maxs");
 
        // set derived values
        VectorCopy (min, PRVM_clientedictvector(e, mins));
@@ -79,7 +72,7 @@ static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
 }
 
 // #3 void(entity e, string m) setmodel
-void VM_CL_setmodel (void)
+static void VM_CL_setmodel (prvm_prog_t *prog)
 {
        prvm_edict_t    *e;
        const char              *m;
@@ -99,7 +92,7 @@ void VM_CL_setmodel (void)
                if (!strcmp(cl.csqc_model_precache[i]->name, m))
                {
                        mod = cl.csqc_model_precache[i];
-                       PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+                       PRVM_clientedictstring(e, model) = PRVM_SetEngineString(prog, mod->name);
                        PRVM_clientedictfloat(e, modelindex) = -(i+1);
                        break;
                }
@@ -111,7 +104,7 @@ void VM_CL_setmodel (void)
                        mod = cl.model_precache[i];
                        if (mod && !strcmp(mod->name, m))
                        {
-                               PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+                               PRVM_clientedictstring(e, model) = PRVM_SetEngineString(prog, mod->name);
                                PRVM_clientedictfloat(e, modelindex) = i;
                                break;
                        }
@@ -124,13 +117,13 @@ void VM_CL_setmodel (void)
        }
        else
        {
-               SetMinMaxSize (e, vec3_origin, vec3_origin);
-               VM_Warning ("setmodel: model '%s' not precached\n", m);
+               SetMinMaxSize (prog, e, vec3_origin, vec3_origin);
+               VM_Warning(prog, "setmodel: model '%s' not precached\n", m);
        }
 }
 
 // #4 void(entity e, vector min, vector max) setsize
-static void VM_CL_setsize (void)
+static void VM_CL_setsize (prvm_prog_t *prog)
 {
        prvm_edict_t    *e;
        float                   *min, *max;
@@ -139,24 +132,24 @@ static void VM_CL_setsize (void)
        e = PRVM_G_EDICT(OFS_PARM0);
        if (e == prog->edicts)
        {
-               VM_Warning("setsize: can not modify world entity\n");
+               VM_Warning(prog, "setsize: can not modify world entity\n");
                return;
        }
        if (e->priv.server->free)
        {
-               VM_Warning("setsize: can not modify free entity\n");
+               VM_Warning(prog, "setsize: can not modify free entity\n");
                return;
        }
        min = PRVM_G_VECTOR(OFS_PARM1);
        max = PRVM_G_VECTOR(OFS_PARM2);
 
-       SetMinMaxSize( e, min, max );
+       SetMinMaxSize( prog, e, min, max );
 
        CL_LinkEdict(e);
 }
 
 // #8 void(entity e, float chan, string samp, float volume, float atten) sound
-static void VM_CL_sound (void)
+static void VM_CL_sound (prvm_prog_t *prog)
 {
        const char                      *sample;
        int                                     channel;
@@ -177,13 +170,13 @@ static void VM_CL_sound (void)
 
        if (volume < 0 || volume > 1)
        {
-               VM_Warning("VM_CL_sound: volume must be in range 0-1\n");
+               VM_Warning(prog, "VM_CL_sound: volume must be in range 0-1\n");
                return;
        }
 
        if (attenuation < 0 || attenuation > 4)
        {
-               VM_Warning("VM_CL_sound: attenuation must be in range 0-4\n");
+               VM_Warning(prog, "VM_CL_sound: attenuation must be in range 0-4\n");
                return;
        }
 
@@ -202,7 +195,7 @@ static void VM_CL_sound (void)
 
        if (!IS_CHAN(channel))
        {
-               VM_Warning("VM_CL_sound: channel must be in range 0-127\n");
+               VM_Warning(prog, "VM_CL_sound: channel must be in range 0-127\n");
                return;
        }
 
@@ -211,7 +204,7 @@ static void VM_CL_sound (void)
 }
 
 // #483 void(vector origin, string sample, float volume, float attenuation) pointsound
-static void VM_CL_pointsound(void)
+static void VM_CL_pointsound(prvm_prog_t *prog)
 {
        const char                      *sample;
        float                           volume;
@@ -227,13 +220,13 @@ static void VM_CL_pointsound(void)
 
        if (volume < 0 || volume > 1)
        {
-               VM_Warning("VM_CL_pointsound: volume must be in range 0-1\n");
+               VM_Warning(prog, "VM_CL_pointsound: volume must be in range 0-1\n");
                return;
        }
 
        if (attenuation < 0 || attenuation > 4)
        {
-               VM_Warning("VM_CL_pointsound: attenuation must be in range 0-4\n");
+               VM_Warning(prog, "VM_CL_pointsound: attenuation must be in range 0-4\n");
                return;
        }
 
@@ -242,16 +235,16 @@ static void VM_CL_pointsound(void)
 }
 
 // #14 entity() spawn
-static void VM_CL_spawn (void)
+static void VM_CL_spawn (prvm_prog_t *prog)
 {
        prvm_edict_t *ed;
-       ed = PRVM_ED_Alloc();
+       ed = PRVM_ED_Alloc(prog);
        VM_RETURN_EDICT(ed);
 }
 
-void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
+static void CL_VM_SetTraceGlobals(prvm_prog_t *prog, const trace_t *trace, int svent)
 {
-       VM_SetTraceGlobals(trace);
+       VM_SetTraceGlobals(prog, trace);
        PRVM_clientglobalfloat(trace_networkentity) = svent;
 }
 
@@ -259,7 +252,7 @@ void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
 #define CL_HitNetworkPlayers(move)     !((move) == MOVE_WORLDONLY || (move) == MOVE_NOMONSTERS)
 
 // #16 void(vector v1, vector v2, float movetype, entity ignore) traceline
-static void VM_CL_traceline (void)
+static void VM_CL_traceline (prvm_prog_t *prog)
 {
        float   *v1, *v2;
        trace_t trace;
@@ -278,11 +271,11 @@ static void VM_CL_traceline (void)
        ent = PRVM_G_EDICT(OFS_PARM3);
 
        if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v2[1]) || IS_NAN(v2[2]))
-               PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
+               prog->error_cmd("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", prog->name, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
 
        trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true, false);
 
-       CL_VM_SetTraceGlobals(&trace, svent);
+       CL_VM_SetTraceGlobals(prog, &trace, svent);
 //     R_TimeReport("traceline");
 }
 
@@ -298,7 +291,7 @@ tracebox (vector1, vector mins, vector maxs, vector2, tryents)
 =================
 */
 // LordHavoc: added this for my own use, VERY useful, similar to traceline
-static void VM_CL_tracebox (void)
+static void VM_CL_tracebox (prvm_prog_t *prog)
 {
        float   *v1, *v2, *m1, *m2;
        trace_t trace;
@@ -318,15 +311,15 @@ static void VM_CL_tracebox (void)
        ent = PRVM_G_EDICT(OFS_PARM5);
 
        if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v2[1]) || IS_NAN(v2[2]))
-               PRVM_ERROR("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
+               prog->error_cmd("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", prog->name, v1[0], v1[1], v1[2], m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
 
        trace = CL_TraceBox(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
 
-       CL_VM_SetTraceGlobals(&trace, svent);
+       CL_VM_SetTraceGlobals(prog, &trace, svent);
 //     R_TimeReport("tracebox");
 }
 
-trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
+static trace_t CL_Trace_Toss (prvm_prog_t *prog, prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
 {
        int i;
        float gravity;
@@ -368,7 +361,7 @@ trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
        return trace;
 }
 
-static void VM_CL_tracetoss (void)
+static void VM_CL_tracetoss (prvm_prog_t *prog)
 {
        trace_t trace;
        prvm_edict_t    *ent;
@@ -382,19 +375,19 @@ static void VM_CL_tracetoss (void)
        ent = PRVM_G_EDICT(OFS_PARM0);
        if (ent == prog->edicts)
        {
-               VM_Warning("tracetoss: can not use world entity\n");
+               VM_Warning(prog, "tracetoss: can not use world entity\n");
                return;
        }
        ignore = PRVM_G_EDICT(OFS_PARM1);
 
-       trace = CL_Trace_Toss (ent, ignore, &svent);
+       trace = CL_Trace_Toss (prog, ent, ignore, &svent);
 
-       CL_VM_SetTraceGlobals(&trace, svent);
+       CL_VM_SetTraceGlobals(prog, &trace, svent);
 }
 
 
 // #20 void(string s) precache_model
-void VM_CL_precache_model (void)
+static void VM_CL_precache_model (prvm_prog_t *prog)
 {
        const char      *name;
        int                     i;
@@ -424,13 +417,13 @@ void VM_CL_precache_model (void)
                                return;
                        }
                }
-               VM_Warning("VM_CL_precache_model: no free models\n");
+               VM_Warning(prog, "VM_CL_precache_model: no free models\n");
                return;
        }
-       VM_Warning("VM_CL_precache_model: model \"%s\" not found\n", name);
+       VM_Warning(prog, "VM_CL_precache_model: model \"%s\" not found\n", name);
 }
 
-int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **list)
+static int CSQC_EntitiesInBox (prvm_prog_t *prog, vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **list)
 {
        prvm_edict_t    *ent;
        int                             i, k;
@@ -447,7 +440,7 @@ int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **li
 }
 
 // #22 entity(vector org, float rad) findradius
-static void VM_CL_findradius (void)
+static void VM_CL_findradius (prvm_prog_t *prog)
 {
        prvm_edict_t    *ent, *chain;
        vec_t                   radius, radius2;
@@ -463,7 +456,7 @@ static void VM_CL_findradius (void)
        else
                chainfield = prog->fieldoffsets.chain;
        if(chainfield < 0)
-               PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
+               prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
 
        chain = (prvm_edict_t *)prog->edicts;
 
@@ -477,7 +470,7 @@ static void VM_CL_findradius (void)
        maxs[0] = org[0] + (radius + 1);
        maxs[1] = org[1] + (radius + 1);
        maxs[2] = org[2] + (radius + 1);
-       numtouchedicts = CSQC_EntitiesInBox(mins, maxs, MAX_EDICTS, touchedicts);
+       numtouchedicts = CSQC_EntitiesInBox(prog, mins, maxs, MAX_EDICTS, touchedicts);
        if (numtouchedicts > MAX_EDICTS)
        {
                // this never happens   //[515]: for what then ?
@@ -514,7 +507,7 @@ static void VM_CL_findradius (void)
 }
 
 // #34 float() droptofloor
-static void VM_CL_droptofloor (void)
+static void VM_CL_droptofloor (prvm_prog_t *prog)
 {
        prvm_edict_t            *ent;
        vec3_t                          end;
@@ -528,12 +521,12 @@ static void VM_CL_droptofloor (void)
        ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
        if (ent == prog->edicts)
        {
-               VM_Warning("droptofloor: can not modify world entity\n");
+               VM_Warning(prog, "droptofloor: can not modify world entity\n");
                return;
        }
        if (ent->priv.server->free)
        {
-               VM_Warning("droptofloor: can not modify free entity\n");
+               VM_Warning(prog, "droptofloor: can not modify free entity\n");
                return;
        }
 
@@ -554,7 +547,7 @@ static void VM_CL_droptofloor (void)
 }
 
 // #35 void(float style, string value) lightstyle
-static void VM_CL_lightstyle (void)
+static void VM_CL_lightstyle (prvm_prog_t *prog)
 {
        int                     i;
        const char      *c;
@@ -565,7 +558,7 @@ static void VM_CL_lightstyle (void)
        c = PRVM_G_STRING(OFS_PARM1);
        if (i >= cl.max_lightstyle)
        {
-               VM_Warning("VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
+               VM_Warning(prog, "VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
                return;
        }
        strlcpy (cl.lightstyle[i].map, c, sizeof (cl.lightstyle[i].map));
@@ -574,7 +567,7 @@ static void VM_CL_lightstyle (void)
 }
 
 // #40 float(entity e) checkbottom
-static void VM_CL_checkbottom (void)
+static void VM_CL_checkbottom (prvm_prog_t *prog)
 {
        static int              cs_yes, cs_no;
        prvm_edict_t    *ent;
@@ -645,14 +638,14 @@ realcheck:
 }
 
 // #41 float(vector v) pointcontents
-static void VM_CL_pointcontents (void)
+static void VM_CL_pointcontents (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_pointcontents);
        PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, CL_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
 }
 
 // #48 void(vector o, vector d, float color, float count) particle
-static void VM_CL_particle (void)
+static void VM_CL_particle (prvm_prog_t *prog)
 {
        float   *org, *dir;
        int             count;
@@ -667,7 +660,7 @@ static void VM_CL_particle (void)
 }
 
 // #74 void(vector pos, string samp, float vol, float atten) ambientsound
-static void VM_CL_ambientsound (void)
+static void VM_CL_ambientsound (prvm_prog_t *prog)
 {
        float   *f;
        sfx_t   *s;
@@ -678,7 +671,7 @@ static void VM_CL_ambientsound (void)
 }
 
 // #92 vector(vector org[, float lpflag]) getlight (DP_QC_GETLIGHT)
-static void VM_CL_getlight (void)
+static void VM_CL_getlight (prvm_prog_t *prog)
 {
        vec3_t ambientcolor, diffusecolor, diffusenormal;
        vec_t *p;
@@ -704,7 +697,6 @@ static void VM_CL_getlight (void)
 
 //============================================================================
 //[515]: SCENE MANAGER builtins
-extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed, int edictnum);//csprogs.c
 
 void CSQC_R_RecalcView (void)
 {
@@ -716,9 +708,8 @@ void CSQC_R_RecalcView (void)
        Matrix4x4_Concat(&viewmodelmatrix_withbob, &r_refdef.view.matrix, &cl.csqc_viewmodelmatrixfromengine);
 }
 
-void CL_RelinkLightFlashes(void);
 //#300 void() clearscene (EXT_CSQC)
-void VM_CL_R_ClearScene (void)
+static void VM_CL_R_ClearScene (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_R_ClearScene);
        // clear renderable entity and light lists
@@ -735,11 +726,9 @@ void VM_CL_R_ClearScene (void)
 }
 
 //#301 void(float mask) addentities (EXT_CSQC)
-extern void CSQC_Predraw (prvm_edict_t *ed);//csprogs.c
-extern void CSQC_Think (prvm_edict_t *ed);//csprogs.c
-void VM_CL_R_AddEntities (void)
+static void VM_CL_R_AddEntities (prvm_prog_t *prog)
 {
-       double t = Sys_DoubleTime();
+       double t = Sys_DirtyTime();
        int                     i, drawmask;
        prvm_edict_t *ed;
        VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntities);
@@ -768,16 +757,18 @@ void VM_CL_R_AddEntities (void)
        }
 
        // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
-       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
+       t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
+       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 }
 
 //#302 void(entity ent) addentity (EXT_CSQC)
-void VM_CL_R_AddEntity (void)
+static void VM_CL_R_AddEntity (prvm_prog_t *prog)
 {
-       double t = Sys_DoubleTime();
+       double t = Sys_DirtyTime();
        VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntity);
        CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0), 0);
-       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
+       t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
+       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 }
 
 //#303 float(float property, ...) setproperty (EXT_CSQC)
@@ -786,7 +777,7 @@ void VM_CL_R_AddEntity (void)
 //#309 float(float property) getproperty
 //#309 vector(float property) getpropertyvec
 // VorteX: make this function be able to return previously set property if new value is not given
-void VM_CL_R_SetView (void)
+static void VM_CL_R_SetView (prvm_prog_t *prog)
 {
        int             c;
        float   *f;
@@ -820,7 +811,7 @@ void VM_CL_R_SetView (void)
                        PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.height;
                        break;
                case VF_VIEWPORT:
-                       VM_Warning("VM_CL_R_GetView : VF_VIEWPORT can't be retrieved, use VF_MIN/VF_SIZE instead\n");
+                       VM_Warning(prog, "VM_CL_R_GetView : VF_VIEWPORT can't be retrieved, use VF_MIN/VF_SIZE instead\n");
                        break;
                case VF_FOV:
                        VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.ortho_x, r_refdef.view.ortho_y, 0);
@@ -916,7 +907,7 @@ void VM_CL_R_SetView (void)
                        break;
                default:
                        PRVM_G_FLOAT(OFS_RETURN) = 0;
-                       VM_Warning("VM_CL_R_GetView : unknown parm %i\n", c);
+                       VM_Warning(prog, "VM_CL_R_GetView : unknown parm %i\n", c);
                        return;
                }
                return;
@@ -1063,16 +1054,16 @@ void VM_CL_R_SetView (void)
                break;
        default:
                PRVM_G_FLOAT(OFS_RETURN) = 0;
-               VM_Warning("VM_CL_R_SetView : unknown parm %i\n", c);
+               VM_Warning(prog, "VM_CL_R_SetView : unknown parm %i\n", c);
                return;
        }
        PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
 //#305 void(vector org, float radius, vector lightcolours[, float style, string cubemapname, float pflags]) adddynamiclight (EXT_CSQC)
-void VM_CL_R_AddDynamicLight (void)
+static void VM_CL_R_AddDynamicLight (prvm_prog_t *prog)
 {
-       double t = Sys_DoubleTime();
+       double t = Sys_DirtyTime();
        vec_t *org;
        float radius = 300;
        vec_t *col;
@@ -1119,13 +1110,14 @@ void VM_CL_R_AddDynamicLight (void)
 
        R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
-       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
+       t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
+       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 }
 
 //============================================================================
 
 //#310 vector (vector v) cs_unproject (EXT_CSQC)
-static void VM_CL_unproject (void)
+static void VM_CL_unproject (prvm_prog_t *prog)
 {
        float   *f;
        vec3_t  temp;
@@ -1142,7 +1134,7 @@ static void VM_CL_unproject (void)
 }
 
 //#311 vector (vector v) cs_project (EXT_CSQC)
-static void VM_CL_project (void)
+static void VM_CL_project (prvm_prog_t *prog)
 {
        float   *f;
        vec3_t  v;
@@ -1164,7 +1156,7 @@ static void VM_CL_project (void)
 }
 
 //#330 float(float stnum) getstatf (EXT_CSQC)
-static void VM_CL_getstatf (void)
+static void VM_CL_getstatf (prvm_prog_t *prog)
 {
        int i;
        union
@@ -1176,7 +1168,7 @@ static void VM_CL_getstatf (void)
        i = (int)PRVM_G_FLOAT(OFS_PARM0);
        if(i < 0 || i >= MAX_CL_STATS)
        {
-               VM_Warning("VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
+               VM_Warning(prog, "VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
                return;
        }
        dat.l = cl.stats[i];
@@ -1184,7 +1176,7 @@ static void VM_CL_getstatf (void)
 }
 
 //#331 float(float stnum) getstati (EXT_CSQC)
-static void VM_CL_getstati (void)
+static void VM_CL_getstati (prvm_prog_t *prog)
 {
        int i, index;
        int firstbit, bitcount;
@@ -1208,7 +1200,7 @@ static void VM_CL_getstati (void)
 
        if(index < 0 || index >= MAX_CL_STATS)
        {
-               VM_Warning("VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
+               VM_Warning(prog, "VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
                return;
        }
        i = cl.stats[index];
@@ -1218,7 +1210,7 @@ static void VM_CL_getstati (void)
 }
 
 //#332 string(float firststnum) getstats (EXT_CSQC)
-static void VM_CL_getstats (void)
+static void VM_CL_getstats (prvm_prog_t *prog)
 {
        int i;
        char t[17];
@@ -1227,15 +1219,15 @@ static void VM_CL_getstats (void)
        if(i < 0 || i > MAX_CL_STATS-4)
        {
                PRVM_G_INT(OFS_RETURN) = OFS_NULL;
-               VM_Warning("VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
+               VM_Warning(prog, "VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
                return;
        }
        strlcpy(t, (char*)&cl.stats[i], sizeof(t));
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
 }
 
 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
-static void VM_CL_setmodelindex (void)
+static void VM_CL_setmodelindex (prvm_prog_t *prog)
 {
        int                             i;
        prvm_edict_t    *t;
@@ -1256,23 +1248,23 @@ static void VM_CL_setmodelindex (void)
        model = CL_GetModelByIndex(i);
        if (!model)
        {
-               VM_Warning("VM_CL_setmodelindex: null model\n");
+               VM_Warning(prog, "VM_CL_setmodelindex: null model\n");
                return;
        }
-       PRVM_clientedictstring(t, model) = PRVM_SetEngineString(model->name);
+       PRVM_clientedictstring(t, model) = PRVM_SetEngineString(prog, model->name);
        PRVM_clientedictfloat(t, modelindex) = i;
 
        // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
        if (model)
        {
-               SetMinMaxSize (t, model->normalmins, model->normalmaxs);
+               SetMinMaxSize (prog, t, model->normalmins, model->normalmaxs);
        }
        else
-               SetMinMaxSize (t, vec3_origin, vec3_origin);
+               SetMinMaxSize (prog, t, vec3_origin, vec3_origin);
 }
 
 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
-static void VM_CL_modelnameforindex (void)
+static void VM_CL_modelnameforindex (prvm_prog_t *prog)
 {
        dp_model_t *model;
 
@@ -1280,11 +1272,11 @@ static void VM_CL_modelnameforindex (void)
 
        PRVM_G_INT(OFS_RETURN) = OFS_NULL;
        model = CL_GetModelByIndex((int)PRVM_G_FLOAT(OFS_PARM0));
-       PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(model->name) : 0;
+       PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(prog, model->name) : 0;
 }
 
 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
-static void VM_CL_particleeffectnum (void)
+static void VM_CL_particleeffectnum (prvm_prog_t *prog)
 {
        int                     i;
        VM_SAFEPARMCOUNT(1, VM_CL_particleeffectnum);
@@ -1295,7 +1287,7 @@ static void VM_CL_particleeffectnum (void)
 }
 
 // #336 void(entity ent, float effectnum, vector start, vector end[, float color]) trailparticles (EXT_CSQC)
-static void VM_CL_trailparticles (void)
+static void VM_CL_trailparticles (prvm_prog_t *prog)
 {
        int                             i;
        float                   *start, *end;
@@ -1313,7 +1305,7 @@ static void VM_CL_trailparticles (void)
 }
 
 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
-static void VM_CL_pointparticles (void)
+static void VM_CL_pointparticles (prvm_prog_t *prog)
 {
        int                     i;
        float n;
@@ -1329,7 +1321,7 @@ static void VM_CL_pointparticles (void)
 }
 
 //#502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count, float extflags) boxparticles (DP_CSQC_BOXPARTICLES)
-static void VM_CL_boxparticles (void)
+static void VM_CL_boxparticles (prvm_prog_t *prog)
 {
        int effectnum;
        // prvm_edict_t *own;
@@ -1368,7 +1360,7 @@ static void VM_CL_boxparticles (void)
 }
 
 //#531 void(float pause) setpause
-static void VM_CL_setpause(void) 
+static void VM_CL_setpause(prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_setpause);
        if ((int)PRVM_G_FLOAT(OFS_PARM0) != 0)
@@ -1378,7 +1370,7 @@ static void VM_CL_setpause(void)
 }
 
 //#343 void(float usecursor) setcursormode (DP_CSQC)
-static void VM_CL_setcursormode (void)
+static void VM_CL_setcursormode (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_setcursormode);
        cl.csqc_wantsmousemove = PRVM_G_FLOAT(OFS_PARM0) != 0;
@@ -1386,7 +1378,7 @@ static void VM_CL_setcursormode (void)
 }
 
 //#344 vector() getmousepos (DP_CSQC)
-static void VM_CL_getmousepos(void)
+static void VM_CL_getmousepos(prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0,VM_CL_getmousepos);
 
@@ -1399,7 +1391,7 @@ static void VM_CL_getmousepos(void)
 }
 
 //#345 float(float framenum) getinputstate (EXT_CSQC)
-static void VM_CL_getinputstate (void)
+static void VM_CL_getinputstate (prvm_prog_t *prog)
 {
        int i, frame;
        VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
@@ -1431,19 +1423,19 @@ static void VM_CL_getinputstate (void)
 }
 
 //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
-static void VM_CL_setsensitivityscale (void)
+static void VM_CL_setsensitivityscale (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_setsensitivityscale);
        cl.sensitivityscale = PRVM_G_FLOAT(OFS_PARM0);
 }
 
 //#347 void() runstandardplayerphysics (EXT_CSQC)
-static void VM_CL_runplayerphysics (void)
+static void VM_CL_runplayerphysics (prvm_prog_t *prog)
 {
 }
 
 //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
-static void VM_CL_getplayerkey (void)
+static void VM_CL_getplayerkey (prvm_prog_t *prog)
 {
        int                     i;
        char            t[128];
@@ -1508,11 +1500,11 @@ static void VM_CL_getplayerkey (void)
                }
        if(!t[0])
                return;
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
 }
 
 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
-static void VM_CL_setlistener (void)
+static void VM_CL_setlistener (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(4, VM_CL_setlistener);
        Matrix4x4_FromVectors(&cl.csqc_listenermatrix, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), PRVM_G_VECTOR(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0));
@@ -1520,7 +1512,7 @@ static void VM_CL_setlistener (void)
 }
 
 //#352 void(string cmdname) registercommand (EXT_CSQC)
-static void VM_CL_registercmd (void)
+static void VM_CL_registercmd (prvm_prog_t *prog)
 {
        char *t;
        VM_SAFEPARMCOUNT(1, VM_CL_registercmd);
@@ -1539,64 +1531,64 @@ static void VM_CL_registercmd (void)
 }
 
 //#360 float() readbyte (EXT_CSQC)
-static void VM_CL_ReadByte (void)
+static void VM_CL_ReadByte (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadByte);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte();
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte(&cl_message);
 }
 
 //#361 float() readchar (EXT_CSQC)
-static void VM_CL_ReadChar (void)
+static void VM_CL_ReadChar (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadChar);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar();
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar(&cl_message);
 }
 
 //#362 float() readshort (EXT_CSQC)
-static void VM_CL_ReadShort (void)
+static void VM_CL_ReadShort (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadShort);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort();
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort(&cl_message);
 }
 
 //#363 float() readlong (EXT_CSQC)
-static void VM_CL_ReadLong (void)
+static void VM_CL_ReadLong (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadLong);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong();
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong(&cl_message);
 }
 
 //#364 float() readcoord (EXT_CSQC)
-static void VM_CL_ReadCoord (void)
+static void VM_CL_ReadCoord (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadCoord);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(cls.protocol);
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(&cl_message, cls.protocol);
 }
 
 //#365 float() readangle (EXT_CSQC)
-static void VM_CL_ReadAngle (void)
+static void VM_CL_ReadAngle (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadAngle);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(cls.protocol);
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(&cl_message, cls.protocol);
 }
 
 //#366 string() readstring (EXT_CSQC)
-static void VM_CL_ReadString (void)
+static void VM_CL_ReadString (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadString);
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(MSG_ReadString());
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
 }
 
 //#367 float() readfloat (EXT_CSQC)
-static void VM_CL_ReadFloat (void)
+static void VM_CL_ReadFloat (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ReadFloat);
-       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat();
+       PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat(&cl_message);
 }
 
 //#501 string() readpicture (DP_CSQC_READWRITEPICTURE)
 extern cvar_t cl_readpicture_force;
-static void VM_CL_ReadPicture (void)
+static void VM_CL_ReadPicture (prvm_prog_t *prog)
 {
        const char *name;
        unsigned char *data;
@@ -1607,8 +1599,8 @@ static void VM_CL_ReadPicture (void)
 
        VM_SAFEPARMCOUNT(0, VM_CL_ReadPicture);
 
-       name = MSG_ReadString();
-       size = MSG_ReadShort();
+       name = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
+       size = MSG_ReadShort(&cl_message);
 
        // check if a texture of that name exists
        // if yes, it is used and the data is discarded
@@ -1625,14 +1617,14 @@ static void VM_CL_ReadPicture (void)
                        // texture found and loaded
                        // skip over the jpeg as we don't need it
                        for(i = 0; i < size; ++i)
-                               (void) MSG_ReadByte();
+                               (void) MSG_ReadByte(&cl_message);
                }
                else
                {
                        // texture not found
                        // use the attached jpeg as texture
                        buf = (unsigned char *) Mem_Alloc(tempmempool, size);
-                       MSG_ReadBytes(size, buf);
+                       MSG_ReadBytes(&cl_message, size, buf);
                        data = JPEG_LoadImage_BGRA(buf, size, NULL);
                        Mem_Free(buf);
                        Draw_NewPic(name, image_width, image_height, false, data);
@@ -1640,12 +1632,12 @@ static void VM_CL_ReadPicture (void)
                }
        }
 
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(name);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, name);
 }
 
 //////////////////////////////////////////////////////////
 
-static void VM_CL_makestatic (void)
+static void VM_CL_makestatic (prvm_prog_t *prog)
 {
        prvm_edict_t *ent;
 
@@ -1654,12 +1646,12 @@ static void VM_CL_makestatic (void)
        ent = PRVM_G_EDICT(OFS_PARM0);
        if (ent == prog->edicts)
        {
-               VM_Warning("makestatic: can not modify world entity\n");
+               VM_Warning(prog, "makestatic: can not modify world entity\n");
                return;
        }
        if (ent->priv.server->free)
        {
-               VM_Warning("makestatic: can not modify free entity\n");
+               VM_Warning(prog, "makestatic: can not modify free entity\n");
                return;
        }
 
@@ -1728,7 +1720,7 @@ static void VM_CL_makestatic (void)
                Con_Printf("Too many static entities");
 
 // throw the entity away now
-       PRVM_ED_Free (ent);
+       PRVM_ED_Free(prog, ent);
 }
 
 //=================================================================//
@@ -1742,30 +1734,30 @@ copies data from one entity to another
 copyentity(src, dst)
 =================
 */
-static void VM_CL_copyentity (void)
+static void VM_CL_copyentity (prvm_prog_t *prog)
 {
        prvm_edict_t *in, *out;
        VM_SAFEPARMCOUNT(2, VM_CL_copyentity);
        in = PRVM_G_EDICT(OFS_PARM0);
        if (in == prog->edicts)
        {
-               VM_Warning("copyentity: can not read world entity\n");
+               VM_Warning(prog, "copyentity: can not read world entity\n");
                return;
        }
        if (in->priv.server->free)
        {
-               VM_Warning("copyentity: can not read free entity\n");
+               VM_Warning(prog, "copyentity: can not read free entity\n");
                return;
        }
        out = PRVM_G_EDICT(OFS_PARM1);
        if (out == prog->edicts)
        {
-               VM_Warning("copyentity: can not modify world entity\n");
+               VM_Warning(prog, "copyentity: can not modify world entity\n");
                return;
        }
        if (out->priv.server->free)
        {
-               VM_Warning("copyentity: can not modify free entity\n");
+               VM_Warning(prog, "copyentity: can not modify free entity\n");
                return;
        }
        memcpy(out->fields.vp, in->fields.vp, prog->entityfields * 4);
@@ -1775,14 +1767,14 @@ static void VM_CL_copyentity (void)
 //=================================================================//
 
 // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
-static void VM_CL_effect (void)
+static void VM_CL_effect (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(5, VM_CL_effect);
        CL_Effect(PRVM_G_VECTOR(OFS_PARM0), (int)PRVM_G_FLOAT(OFS_PARM1), (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), PRVM_G_FLOAT(OFS_PARM4));
 }
 
 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
-static void VM_CL_te_blood (void)
+static void VM_CL_te_blood (prvm_prog_t *prog)
 {
        float   *pos;
        vec3_t  pos2;
@@ -1795,7 +1787,7 @@ static void VM_CL_te_blood (void)
 }
 
 // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
-static void VM_CL_te_bloodshower (void)
+static void VM_CL_te_bloodshower (prvm_prog_t *prog)
 {
        vec_t speed;
        vec3_t vel1, vel2;
@@ -1813,7 +1805,7 @@ static void VM_CL_te_bloodshower (void)
 }
 
 // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
-static void VM_CL_te_explosionrgb (void)
+static void VM_CL_te_explosionrgb (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1827,28 +1819,28 @@ static void VM_CL_te_explosionrgb (void)
 }
 
 // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
-static void VM_CL_te_particlecube (void)
+static void VM_CL_te_particlecube (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(7, VM_CL_te_particlecube);
        CL_ParticleCube(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), PRVM_G_FLOAT(OFS_PARM5), PRVM_G_FLOAT(OFS_PARM6));
 }
 
 // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
-static void VM_CL_te_particlerain (void)
+static void VM_CL_te_particlerain (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(5, VM_CL_te_particlerain);
        CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 0);
 }
 
 // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
-static void VM_CL_te_particlesnow (void)
+static void VM_CL_te_particlesnow (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(5, VM_CL_te_particlesnow);
        CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 1);
 }
 
 // #411 void(vector org, vector vel, float howmany) te_spark
-static void VM_CL_te_spark (void)
+static void VM_CL_te_spark (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1861,7 +1853,7 @@ static void VM_CL_te_spark (void)
 
 extern cvar_t cl_sound_ric_gunshot;
 // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
-static void VM_CL_te_gunshotquad (void)
+static void VM_CL_te_gunshotquad (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1885,7 +1877,7 @@ static void VM_CL_te_gunshotquad (void)
 }
 
 // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
-static void VM_CL_te_spikequad (void)
+static void VM_CL_te_spikequad (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1906,7 +1898,7 @@ static void VM_CL_te_spikequad (void)
 }
 
 // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
-static void VM_CL_te_superspikequad (void)
+static void VM_CL_te_superspikequad (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1927,7 +1919,7 @@ static void VM_CL_te_superspikequad (void)
 }
 
 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
-static void VM_CL_te_explosionquad (void)
+static void VM_CL_te_explosionquad (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1940,7 +1932,7 @@ static void VM_CL_te_explosionquad (void)
 }
 
 // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
-static void VM_CL_te_smallflash (void)
+static void VM_CL_te_smallflash (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1952,7 +1944,7 @@ static void VM_CL_te_smallflash (void)
 }
 
 // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
-static void VM_CL_te_customflash (void)
+static void VM_CL_te_customflash (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1966,7 +1958,7 @@ static void VM_CL_te_customflash (void)
 }
 
 // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_gunshot (void)
+static void VM_CL_te_gunshot (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -1990,7 +1982,7 @@ static void VM_CL_te_gunshot (void)
 }
 
 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_spike (void)
+static void VM_CL_te_spike (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2011,7 +2003,7 @@ static void VM_CL_te_spike (void)
 }
 
 // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_superspike (void)
+static void VM_CL_te_superspike (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2032,7 +2024,7 @@ static void VM_CL_te_superspike (void)
 }
 
 // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_explosion (void)
+static void VM_CL_te_explosion (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2045,7 +2037,7 @@ static void VM_CL_te_explosion (void)
 }
 
 // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_tarexplosion (void)
+static void VM_CL_te_tarexplosion (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2058,7 +2050,7 @@ static void VM_CL_te_tarexplosion (void)
 }
 
 // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_wizspike (void)
+static void VM_CL_te_wizspike (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2071,7 +2063,7 @@ static void VM_CL_te_wizspike (void)
 }
 
 // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_knightspike (void)
+static void VM_CL_te_knightspike (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2084,21 +2076,21 @@ static void VM_CL_te_knightspike (void)
 }
 
 // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_lavasplash (void)
+static void VM_CL_te_lavasplash (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_te_lavasplash);
        CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
 }
 
 // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_teleport (void)
+static void VM_CL_te_teleport (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_te_teleport);
        CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
 }
 
 // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_explosion2 (void)
+static void VM_CL_te_explosion2 (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2, color;
@@ -2123,35 +2115,35 @@ static void VM_CL_te_explosion2 (void)
 
 
 // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_lightning1 (void)
+static void VM_CL_te_lightning1 (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(3, VM_CL_te_lightning1);
        CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt, true);
 }
 
 // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_lightning2 (void)
+static void VM_CL_te_lightning2 (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(3, VM_CL_te_lightning2);
        CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt2, true);
 }
 
 // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_lightning3 (void)
+static void VM_CL_te_lightning3 (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(3, VM_CL_te_lightning3);
        CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt3, false);
 }
 
 // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
-static void VM_CL_te_beam (void)
+static void VM_CL_te_beam (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(3, VM_CL_te_beam);
        CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_beam, false);
 }
 
 // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
-static void VM_CL_te_plasmaburn (void)
+static void VM_CL_te_plasmaburn (prvm_prog_t *prog)
 {
        float           *pos;
        vec3_t          pos2;
@@ -2163,7 +2155,7 @@ static void VM_CL_te_plasmaburn (void)
 }
 
 // #457 void(vector org, vector velocity, float howmany) te_flamejet (DP_TE_FLAMEJET)
-static void VM_CL_te_flamejet (void)
+static void VM_CL_te_flamejet (prvm_prog_t *prog)
 {
        float *pos;
        vec3_t pos2;
@@ -2177,7 +2169,7 @@ static void VM_CL_te_flamejet (void)
 
 
 // #443 void(entity e, entity tagentity, string tagname) setattachment
-void VM_CL_setattachment (void)
+static void VM_CL_setattachment (prvm_prog_t *prog)
 {
        prvm_edict_t *e;
        prvm_edict_t *tagentity;
@@ -2193,12 +2185,12 @@ void VM_CL_setattachment (void)
 
        if (e == prog->edicts)
        {
-               VM_Warning("setattachment: can not modify world entity\n");
+               VM_Warning(prog, "setattachment: can not modify world entity\n");
                return;
        }
        if (e->priv.server->free)
        {
-               VM_Warning("setattachment: can not modify free entity\n");
+               VM_Warning(prog, "setattachment: can not modify free entity\n");
                return;
        }
 
@@ -2227,7 +2219,7 @@ void VM_CL_setattachment (void)
 /////////////////////////////////////////
 // DP_MD3_TAGINFO extension coded by VorteX
 
-int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
+static int CL_GetTagIndex (prvm_prog_t *prog, prvm_edict_t *e, const char *tagname)
 {
        dp_model_t *model = CL_GetModelFromEdict(e);
        if (model)
@@ -2236,7 +2228,7 @@ int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
                return -1;
 }
 
-int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
+static int CL_GetExtendedTagInfo (prvm_prog_t *prog, prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
 {
        int r;
        dp_model_t *model;
@@ -2260,7 +2252,7 @@ int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, cons
        return 1;
 }
 
-int CL_GetPitchSign(prvm_edict_t *ent)
+int CL_GetPitchSign(prvm_prog_t *prog, prvm_edict_t *ent)
 {
        dp_model_t *model;
        if ((model = CL_GetModelFromEdict(ent)) && model->type == mod_alias)
@@ -2268,7 +2260,7 @@ int CL_GetPitchSign(prvm_edict_t *ent)
        return 1;
 }
 
-void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
+void CL_GetEntityMatrix (prvm_prog_t *prog, prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
 {
        float scale;
        float pitchsign = 1;
@@ -2293,21 +2285,21 @@ void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatri
        }
        else
        {
-               pitchsign = CL_GetPitchSign(ent);
+               pitchsign = CL_GetPitchSign(prog, ent);
                Matrix4x4_CreateFromQuakeEntity(out, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], pitchsign * PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], scale);
        }
 }
 
-int CL_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
+static int CL_GetEntityLocalTagMatrix(prvm_prog_t *prog, prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
 {
        dp_model_t *model;
        if (tagindex >= 0
         && (model = CL_GetModelFromEdict(ent))
         && model->animscenes)
        {
-               VM_GenerateFrameGroupBlend(ent->priv.server->framegroupblend, ent);
+               VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
                VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model);
-               VM_UpdateEdictSkeleton(ent, model, ent->priv.server->frameblend);
+               VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
                return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
        }
        *out = identitymatrix;
@@ -2324,7 +2316,7 @@ int CL_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out
 extern cvar_t cl_bob;
 extern cvar_t cl_bobcycle;
 extern cvar_t cl_bobup;
-int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
+int CL_GetTagMatrix (prvm_prog_t *prog, matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 {
        int ret;
        int attachloop;
@@ -2350,10 +2342,10 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
                        return 5;
                // apply transformation by child's tagindex on parent entity and then
                // by parent entity itself
-               ret = CL_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
+               ret = CL_GetEntityLocalTagMatrix(prog, ent, tagindex - 1, &attachmatrix);
                if(ret && attachloop == 0)
                        return ret;
-               CL_GetEntityMatrix(ent, &entitymatrix, false);
+               CL_GetEntityMatrix(prog, ent, &entitymatrix, false);
                Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                // next iteration we process the parent entity
@@ -2372,7 +2364,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
        {
                Matrix4x4_Copy(&tagmatrix, out);
 
-               CL_GetEntityMatrix(prog->edicts, &entitymatrix, true);
+               CL_GetEntityMatrix(prog, prog->edicts, &entitymatrix, true);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
 
                /*
@@ -2402,7 +2394,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 }
 
 // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
-void VM_CL_gettagindex (void)
+static void VM_CL_gettagindex (prvm_prog_t *prog)
 {
        prvm_edict_t *ent;
        const char *tag_name;
@@ -2414,12 +2406,12 @@ void VM_CL_gettagindex (void)
        tag_name = PRVM_G_STRING(OFS_PARM1);
        if (ent == prog->edicts)
        {
-               VM_Warning("VM_CL_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
+               VM_Warning(prog, "VM_CL_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
                return;
        }
        if (ent->priv.server->free)
        {
-               VM_Warning("VM_CL_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
+               VM_Warning(prog, "VM_CL_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
                return;
        }
 
@@ -2428,7 +2420,7 @@ void VM_CL_gettagindex (void)
                Con_DPrintf("VM_CL_gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
        else
        {
-               tag_index = CL_GetTagIndex(ent, tag_name);
+               tag_index = CL_GetTagIndex(prog, ent, tag_name);
                if (tag_index == 0)
                        Con_DPrintf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
        }
@@ -2436,7 +2428,7 @@ void VM_CL_gettagindex (void)
 }
 
 // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
-void VM_CL_gettaginfo (void)
+static void VM_CL_gettaginfo (prvm_prog_t *prog)
 {
        prvm_edict_t *e;
        int tagindex;
@@ -2452,18 +2444,18 @@ void VM_CL_gettaginfo (void)
 
        e = PRVM_G_EDICT(OFS_PARM0);
        tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
-       returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
+       returncode = CL_GetTagMatrix(prog, &tag_matrix, e, tagindex);
        Matrix4x4_ToVectors(&tag_matrix, PRVM_clientglobalvector(v_forward), le, PRVM_clientglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));
        VectorScale(le, -1, PRVM_clientglobalvector(v_right));
        model = CL_GetModelFromEdict(e);
-       VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
+       VM_GenerateFrameGroupBlend(prog, e->priv.server->framegroupblend, e);
        VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
-       VM_UpdateEdictSkeleton(e, model, e->priv.server->frameblend);
-       CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
+       VM_UpdateEdictSkeleton(prog, e, model, e->priv.server->frameblend);
+       CL_GetExtendedTagInfo(prog, e, tagindex, &parentindex, &tagname, &tag_localmatrix);
        Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 
        PRVM_clientglobalfloat(gettaginfo_parent) = parentindex;
-       PRVM_clientglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
+       PRVM_clientglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(prog, tagname) : 0;
        VectorCopy(trans, PRVM_clientglobalvector(gettaginfo_offset));
        VectorCopy(fo, PRVM_clientglobalvector(gettaginfo_forward));
        VectorScale(le, -1, PRVM_clientglobalvector(gettaginfo_right));
@@ -2472,10 +2464,10 @@ void VM_CL_gettaginfo (void)
        switch(returncode)
        {
                case 1:
-                       VM_Warning("gettagindex: can't affect world entity\n");
+                       VM_Warning(prog, "gettagindex: can't affect world entity\n");
                        break;
                case 2:
-                       VM_Warning("gettagindex: can't affect free entity\n");
+                       VM_Warning(prog, "gettagindex: can't affect free entity\n");
                        break;
                case 3:
                        Con_DPrintf("CL_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
@@ -2572,7 +2564,7 @@ typedef struct vmparticlespawner_s
 vmparticlespawner_t vmpartspawner;
 
 // TODO: automatic max_themes grow
-static void VM_InitParticleSpawner (int maxthemes)
+static void VM_InitParticleSpawner (prvm_prog_t *prog, int maxthemes)
 {
        // bound max themes to not be an insane value
        if (maxthemes < 4)
@@ -2657,7 +2649,7 @@ static void VM_ResetParticleTheme (vmparticletheme_t *theme)
 }
 
 // particle theme -> QC globals
-void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
+static void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
 {
        *vmpartspawner.particle_type = theme->typeindex;
        *vmpartspawner.particle_blendmode = theme->blendmode;
@@ -2698,7 +2690,7 @@ void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
 }
 
 // QC globals ->  particle theme
-void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
+static void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
 {
        theme->typeindex = (unsigned short)*vmpartspawner.particle_type;
        theme->blendmode = (pblend_t)(int)*vmpartspawner.particle_blendmode;
@@ -2732,48 +2724,48 @@ void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
 
 // init particle spawner interface
 // # float(float max_themes) initparticlespawner
-void VM_CL_InitParticleSpawner (void)
+static void VM_CL_InitParticleSpawner (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_InitParticleSpawner);
-       VM_InitParticleSpawner((int)PRVM_G_FLOAT(OFS_PARM0));
+       VM_InitParticleSpawner(prog, (int)PRVM_G_FLOAT(OFS_PARM0));
        vmpartspawner.themes[0].initialized = true;
        VM_ResetParticleTheme(&vmpartspawner.themes[0]);
        PRVM_G_FLOAT(OFS_RETURN) = (vmpartspawner.verified == true) ? 1 : 0;
 }
 
 // void() resetparticle
-void VM_CL_ResetParticle (void)
+static void VM_CL_ResetParticle (prvm_prog_t *prog)
 {
        VM_SAFEPARMCOUNT(0, VM_CL_ResetParticle);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_ResetParticle: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_ResetParticle: particle spawner not initialized\n");
                return;
        }
        VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
 }
 
 // void(float themenum) particletheme
-void VM_CL_ParticleTheme (void)
+static void VM_CL_ParticleTheme (prvm_prog_t *prog)
 {
        int themenum;
 
        VM_SAFEPARMCOUNT(1, VM_CL_ParticleTheme);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_ParticleTheme: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_ParticleTheme: particle spawner not initialized\n");
                return;
        }
        themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
        if (themenum < 0 || themenum >= vmpartspawner.max_themes)
        {
-               VM_Warning("VM_CL_ParticleTheme: bad theme number %i\n", themenum);
+               VM_Warning(prog, "VM_CL_ParticleTheme: bad theme number %i\n", themenum);
                VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
                return;
        }
        if (vmpartspawner.themes[themenum].initialized == false)
        {
-               VM_Warning("VM_CL_ParticleTheme: theme #%i not exists\n", themenum);
+               VM_Warning(prog, "VM_CL_ParticleTheme: theme #%i not exists\n", themenum);
                VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
                return;
        }
@@ -2783,14 +2775,14 @@ void VM_CL_ParticleTheme (void)
 
 // float() saveparticletheme
 // void(float themenum) updateparticletheme
-void VM_CL_ParticleThemeSave (void)
+static void VM_CL_ParticleThemeSave (prvm_prog_t *prog)
 {
        int themenum;
 
        VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_ParticleThemeSave);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_ParticleThemeSave: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_ParticleThemeSave: particle spawner not initialized\n");
                return;
        }
        // allocate new theme, save it and return
@@ -2802,9 +2794,9 @@ void VM_CL_ParticleThemeSave (void)
                if (themenum >= vmpartspawner.max_themes)
                {
                        if (vmpartspawner.max_themes == 2048)
-                               VM_Warning("VM_CL_ParticleThemeSave: no free theme slots\n");
+                               VM_Warning(prog, "VM_CL_ParticleThemeSave: no free theme slots\n");
                        else
-                               VM_Warning("VM_CL_ParticleThemeSave: no free theme slots, try initparticlespawner() with highter max_themes\n");
+                               VM_Warning(prog, "VM_CL_ParticleThemeSave: no free theme slots, try initparticlespawner() with highter max_themes\n");
                        PRVM_G_FLOAT(OFS_RETURN) = -1;
                        return;
                }
@@ -2817,7 +2809,7 @@ void VM_CL_ParticleThemeSave (void)
        themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
        if (themenum < 0 || themenum >= vmpartspawner.max_themes)
        {
-               VM_Warning("VM_CL_ParticleThemeSave: bad theme number %i\n", themenum);
+               VM_Warning(prog, "VM_CL_ParticleThemeSave: bad theme number %i\n", themenum);
                return;
        }
        vmpartspawner.themes[themenum].initialized = true;
@@ -2825,26 +2817,26 @@ void VM_CL_ParticleThemeSave (void)
 }
 
 // void(float themenum) freeparticletheme
-void VM_CL_ParticleThemeFree (void)
+static void VM_CL_ParticleThemeFree (prvm_prog_t *prog)
 {
        int themenum;
 
        VM_SAFEPARMCOUNT(1, VM_CL_ParticleThemeFree);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_ParticleThemeFree: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_ParticleThemeFree: particle spawner not initialized\n");
                return;
        }
        themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
        // check parms
        if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
        {
-               VM_Warning("VM_CL_ParticleThemeFree: bad theme number %i\n", themenum);
+               VM_Warning(prog, "VM_CL_ParticleThemeFree: bad theme number %i\n", themenum);
                return;
        }
        if (vmpartspawner.themes[themenum].initialized == false)
        {
-               VM_Warning("VM_CL_ParticleThemeFree: theme #%i already freed\n", themenum);
+               VM_Warning(prog, "VM_CL_ParticleThemeFree: theme #%i already freed\n", themenum);
                VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
                return;
        }
@@ -2855,7 +2847,7 @@ void VM_CL_ParticleThemeFree (void)
 
 // float(vector org, vector dir, [float theme]) particle
 // returns 0 if failed, 1 if succesful
-void VM_CL_SpawnParticle (void)
+static void VM_CL_SpawnParticle (prvm_prog_t *prog)
 {
        float *org, *dir;
        vmparticletheme_t *theme;
@@ -2865,7 +2857,7 @@ void VM_CL_SpawnParticle (void)
        VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_SpawnParticle2);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_SpawnParticle: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_SpawnParticle: particle spawner not initialized\n");
                PRVM_G_FLOAT(OFS_RETURN) = 0; 
                return;
        }
@@ -2890,7 +2882,7 @@ void VM_CL_SpawnParticle (void)
                themenum = (int)PRVM_G_FLOAT(OFS_PARM2);
                if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
                {
-                       VM_Warning("VM_CL_SpawnParticle: bad theme number %i\n", themenum);
+                       VM_Warning(prog, "VM_CL_SpawnParticle: bad theme number %i\n", themenum);
                        PRVM_G_FLOAT(OFS_RETURN) = 0; 
                        return;
                }
@@ -2911,7 +2903,7 @@ void VM_CL_SpawnParticle (void)
 
 // float(vector org, vector dir, float spawndelay, float collisiondelay, [float theme]) delayedparticle
 // returns 0 if failed, 1 if success
-void VM_CL_SpawnParticleDelayed (void)
+static void VM_CL_SpawnParticleDelayed (prvm_prog_t *prog)
 {
        float *org, *dir;
        vmparticletheme_t *theme;
@@ -2921,7 +2913,7 @@ void VM_CL_SpawnParticleDelayed (void)
        VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_SpawnParticle2);
        if (vmpartspawner.verified == false)
        {
-               VM_Warning("VM_CL_SpawnParticle: particle spawner not initialized\n");
+               VM_Warning(prog, "VM_CL_SpawnParticle: particle spawner not initialized\n");
                PRVM_G_FLOAT(OFS_RETURN) = 0; 
                return;
        }
@@ -2934,7 +2926,7 @@ void VM_CL_SpawnParticleDelayed (void)
                themenum = (int)PRVM_G_FLOAT(OFS_PARM4);
                if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
                {
-                       VM_Warning("VM_CL_SpawnParticle: bad theme number %i\n", themenum);
+                       VM_Warning(prog, "VM_CL_SpawnParticle: bad theme number %i\n", themenum);
                        PRVM_G_FLOAT(OFS_RETURN) = 0;  
                        return;
                }
@@ -2959,7 +2951,7 @@ void VM_CL_SpawnParticleDelayed (void)
 // vector(float entitynum, float whatfld) getentityvec;
 // querying engine-drawn entity
 // VorteX: currently it's only tested with whatfld = 1..7
-void VM_CL_GetEntity (void)
+static void VM_CL_GetEntity (prvm_prog_t *prog)
 {
        int entnum, fieldnum;
        float org[3], v1[3], v2[3];
@@ -3037,55 +3029,14 @@ void VM_CL_GetEntity (void)
 //QC POLYGON functions
 //====================
 
-#define VMPOLYGONS_MAXPOINTS 64
-
-typedef struct vmpolygons_triangle_s
-{
-       rtexture_t              *texture;
-       int                             drawflag;
-       qboolean hasalpha;
-       unsigned short  elements[3];
-}vmpolygons_triangle_t;
-
-typedef struct vmpolygons_s
-{
-       mempool_t               *pool;
-       qboolean                initialized;
-       double          progstarttime;
-
-       int                             max_vertices;
-       int                             num_vertices;
-       float                   *data_vertex3f;
-       float                   *data_color4f;
-       float                   *data_texcoord2f;
-
-       int                             max_triangles;
-       int                             num_triangles;
-       vmpolygons_triangle_t *data_triangles;
-       unsigned short  *data_sortedelement3s;
-
-       qboolean                begin_active;
-       int     begin_draw2d;
-       rtexture_t              *begin_texture;
-       int                             begin_drawflag;
-       int                             begin_vertices;
-       float                   begin_vertex[VMPOLYGONS_MAXPOINTS][3];
-       float                   begin_color[VMPOLYGONS_MAXPOINTS][4];
-       float                   begin_texcoord[VMPOLYGONS_MAXPOINTS][2];
-       qboolean                begin_texture_hasalpha;
-} vmpolygons_t;
-
-// FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
-vmpolygons_t vmpolygons[PRVM_MAXPROGS];
-
 //#304 void() renderscene (EXT_CSQC)
 // moved that here to reset the polygons,
 // resetting them earlier causes R_Mesh_Draw to be called with numvertices = 0
 // --blub
-void VM_CL_R_RenderScene (void)
+static void VM_CL_R_RenderScene (prvm_prog_t *prog)
 {
-       double t = Sys_DoubleTime();
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       double t = Sys_DirtyTime();
+       vmpolygons_t *polys = &prog->vmpolygons;
        VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
 
        // we need to update any RENDER_VIEWMODEL entities at this point because
@@ -3096,10 +3047,10 @@ void VM_CL_R_RenderScene (void)
        R_RenderView();
 
        polys->num_vertices = polys->num_triangles = 0;
-       polys->progstarttime = prog->starttime;
 
        // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
-       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
+       t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
+       prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 }
 
 static void VM_ResizePolygons(vmpolygons_t *polys)
@@ -3150,9 +3101,7 @@ static void VM_InitPolygons (vmpolygons_t* polys)
 static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
 {
        int surfacelistindex;
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
-       if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
-               return;
+       vmpolygons_t *polys = (vmpolygons_t *)ent;
 //     R_Mesh_ResetTextureState();
        R_EntityMatrix(&identitymatrix);
        GL_CullFace(GL_NONE);
@@ -3179,7 +3128,7 @@ static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t
        }
 }
 
-void VMPolygons_Store(vmpolygons_t *polys)
+static void VMPolygons_Store(vmpolygons_t *polys)
 {
        qboolean hasalpha;
        int i;
@@ -3241,10 +3190,10 @@ void VMPolygons_Store(vmpolygons_t *polys)
 
 // TODO: move this into the client code and clean-up everything else, too! [1/6/2008 Black]
 // LordHavoc: agreed, this is a mess
-void VM_CL_AddPolygonsToMeshQueue (void)
+void VM_CL_AddPolygonsToMeshQueue (prvm_prog_t *prog)
 {
        int i;
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       vmpolygons_t *polys = &prog->vmpolygons;
        vec3_t center;
 
        // only add polygons of the currently active prog to the queue - if there is none, we're done
@@ -3257,7 +3206,7 @@ void VM_CL_AddPolygonsToMeshQueue (void)
        for (i = 0;i < polys->num_triangles;i++)
        {
                VectorMAMAM(1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[0], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[1], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[2], center);
-               R_MeshQueue_AddTransparent(center, VM_DrawPolygonCallback, NULL, i, NULL);
+               R_MeshQueue_AddTransparent(center, VM_DrawPolygonCallback, (entity_render_t *)polys, i, NULL);
        }
 
        /*polys->num_triangles = 0; // now done after rendering the scene,
@@ -3265,11 +3214,11 @@ void VM_CL_AddPolygonsToMeshQueue (void)
 }
 
 //void(string texturename, float flag[, float is2d]) R_BeginPolygon
-void VM_CL_R_PolygonBegin (void)
+static void VM_CL_R_PolygonBegin (prvm_prog_t *prog)
 {
        const char              *picname;
        skinframe_t     *sf;
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       vmpolygons_t *polys = &prog->vmpolygons;
        int tf;
 
        // TODO instead of using skinframes here (which provides the benefit of
@@ -3280,15 +3229,9 @@ void VM_CL_R_PolygonBegin (void)
 
        if (!polys->initialized)
                VM_InitPolygons(polys);
-       if(polys->progstarttime != prog->starttime)
-       {
-               // from another progs? then reset the polys first (fixes crashes on map change, because that can make skinframe textures invalid)
-               polys->num_vertices = polys->num_triangles = 0;
-               polys->progstarttime = prog->starttime;
-       }
        if (polys->begin_active)
        {
-               VM_Warning("VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
+               VM_Warning(prog, "VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
                return;
        }
        picname = PRVM_G_STRING(OFS_PARM0);
@@ -3322,21 +3265,21 @@ void VM_CL_R_PolygonBegin (void)
 }
 
 //void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
-void VM_CL_R_PolygonVertex (void)
+static void VM_CL_R_PolygonVertex (prvm_prog_t *prog)
 {
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       vmpolygons_t *polys = &prog->vmpolygons;
 
        VM_SAFEPARMCOUNT(4, VM_CL_R_PolygonVertex);
 
        if (!polys->begin_active)
        {
-               VM_Warning("VM_CL_R_PolygonVertex: VM_CL_R_PolygonBegin wasn't called\n");
+               VM_Warning(prog, "VM_CL_R_PolygonVertex: VM_CL_R_PolygonBegin wasn't called\n");
                return;
        }
 
        if (polys->begin_vertices >= VMPOLYGONS_MAXPOINTS)
        {
-               VM_Warning("VM_CL_R_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
+               VM_Warning(prog, "VM_CL_R_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
                return;
        }
 
@@ -3353,21 +3296,21 @@ void VM_CL_R_PolygonVertex (void)
 }
 
 //void() R_EndPolygon
-void VM_CL_R_PolygonEnd (void)
+static void VM_CL_R_PolygonEnd (prvm_prog_t *prog)
 {
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       vmpolygons_t *polys = &prog->vmpolygons;
 
        VM_SAFEPARMCOUNT(0, VM_CL_R_PolygonEnd);
        if (!polys->begin_active)
        {
-               VM_Warning("VM_CL_R_PolygonEnd: VM_CL_R_PolygonBegin wasn't called\n");
+               VM_Warning(prog, "VM_CL_R_PolygonEnd: VM_CL_R_PolygonBegin wasn't called\n");
                return;
        }
        polys->begin_active = false;
        if (polys->begin_vertices >= 3)
                VMPolygons_Store(polys);
        else
-               VM_Warning("VM_CL_R_PolygonEnd: %i vertices isn't a good choice\n", polys->begin_vertices);
+               VM_Warning(prog, "VM_CL_R_PolygonEnd: %i vertices isn't a good choice\n", polys->begin_vertices);
 }
 
 static vmpolygons_t debugPolys;
@@ -3436,8 +3379,9 @@ is not a staircase.
 
 =============
 */
-qboolean CL_CheckBottom (prvm_edict_t *ent)
+static qboolean CL_CheckBottom (prvm_edict_t *ent)
 {
+       prvm_prog_t *prog = CLVM_prog;
        vec3_t  mins, maxs, start, stop;
        trace_t trace;
        int             x, y;
@@ -3504,8 +3448,9 @@ The move will be adjusted for slopes and stairs, but if the move isn't
 possible, no move is done and false is returned
 =============
 */
-qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
+static qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
 {
+       prvm_prog_t *prog = CLVM_prog;
        float           dz;
        vec3_t          oldorg, neworg, end, traceendpos;
        trace_t         trace;
@@ -3534,7 +3479,7 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
                        }
                        trace = CL_TraceBox(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
                        if (settrace)
-                               CL_VM_SetTraceGlobals(&trace, svent);
+                               CL_VM_SetTraceGlobals(prog, &trace, svent);
 
                        if (trace.fraction == 1)
                        {
@@ -3562,14 +3507,14 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
 
        trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
        if (settrace)
-               CL_VM_SetTraceGlobals(&trace, svent);
+               CL_VM_SetTraceGlobals(prog, &trace, svent);
 
        if (trace.startsolid)
        {
                neworg[2] -= sv_stepheight.value;
                trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
                if (settrace)
-                       CL_VM_SetTraceGlobals(&trace, svent);
+                       CL_VM_SetTraceGlobals(prog, &trace, svent);
                if (trace.startsolid)
                        return false;
        }
@@ -3622,7 +3567,7 @@ VM_CL_walkmove
 float(float yaw, float dist[, settrace]) walkmove
 ===============
 */
-static void VM_CL_walkmove (void)
+static void VM_CL_walkmove (prvm_prog_t *prog)
 {
        prvm_edict_t    *ent;
        float   yaw, dist;
@@ -3639,12 +3584,12 @@ static void VM_CL_walkmove (void)
        ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
        if (ent == prog->edicts)
        {
-               VM_Warning("walkmove: can not modify world entity\n");
+               VM_Warning(prog, "walkmove: can not modify world entity\n");
                return;
        }
        if (ent->priv.server->free)
        {
-               VM_Warning("walkmove: can not modify free entity\n");
+               VM_Warning(prog, "walkmove: can not modify free entity\n");
                return;
        }
        yaw = PRVM_G_FLOAT(OFS_PARM0);
@@ -3679,12 +3624,12 @@ VM_CL_serverkey
 string(string key) serverkey
 ===============
 */
-void VM_CL_serverkey(void)
+static void VM_CL_serverkey(prvm_prog_t *prog)
 {
        char string[VM_STRINGTEMP_LENGTH];
        VM_SAFEPARMCOUNT(1, VM_CL_serverkey);
        InfoString_GetValue(cl.qw_serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
 }
 
 /*
@@ -3697,7 +3642,7 @@ Should be fast but can be inexact.
 float checkpvs(vector viewpos, entity viewee) = #240;
 =================
 */
-static void VM_CL_checkpvs (void)
+static void VM_CL_checkpvs (prvm_prog_t *prog)
 {
        vec3_t viewpos;
        prvm_edict_t *viewee;
@@ -3715,7 +3660,7 @@ static void VM_CL_checkpvs (void)
 
        if(viewee->priv.required->free)
        {
-               VM_Warning("checkpvs: can not check free entity\n");
+               VM_Warning(prog, "checkpvs: can not check free entity\n");
                PRVM_G_FLOAT(OFS_RETURN) = 4;
                return;
        }
@@ -3758,7 +3703,7 @@ static void VM_CL_checkpvs (void)
 }
 
 // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure  (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
-static void VM_CL_skel_create(void)
+static void VM_CL_skel_create(prvm_prog_t *prog)
 {
        int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
        dp_model_t *model = CL_GetModelByIndex(modelindex);
@@ -3782,7 +3727,7 @@ static void VM_CL_skel_create(void)
 }
 
 // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
-static void VM_CL_skel_build(void)
+static void VM_CL_skel_build(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        skeleton_t *skeleton;
@@ -3806,7 +3751,7 @@ static void VM_CL_skel_build(void)
        firstbone = max(0, firstbone);
        lastbone = min(lastbone, model->num_bones - 1);
        lastbone = min(lastbone, skeleton->model->num_bones - 1);
-       VM_GenerateFrameGroupBlend(framegroupblend, ed);
+       VM_GenerateFrameGroupBlend(prog, framegroupblend, ed);
        VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model);
        blendfrac = 1.0f - retainfrac;
        for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
@@ -3826,7 +3771,7 @@ static void VM_CL_skel_build(void)
 }
 
 // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
-static void VM_CL_skel_get_numbones(void)
+static void VM_CL_skel_get_numbones(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        skeleton_t *skeleton;
@@ -3837,7 +3782,7 @@ static void VM_CL_skel_get_numbones(void)
 }
 
 // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
-static void VM_CL_skel_get_bonename(void)
+static void VM_CL_skel_get_bonename(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3847,11 +3792,11 @@ static void VM_CL_skel_get_bonename(void)
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(skeleton->model->data_bones[bonenum].name);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, skeleton->model->data_bones[bonenum].name);
 }
 
 // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
-static void VM_CL_skel_get_boneparent(void)
+static void VM_CL_skel_get_boneparent(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3865,7 +3810,7 @@ static void VM_CL_skel_get_boneparent(void)
 }
 
 // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
-static void VM_CL_skel_find_bone(void)
+static void VM_CL_skel_find_bone(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        const char *tagname = PRVM_G_STRING(OFS_PARM1);
@@ -3877,7 +3822,7 @@ static void VM_CL_skel_find_bone(void)
 }
 
 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
-static void VM_CL_skel_get_bonerel(void)
+static void VM_CL_skel_get_bonerel(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3901,7 +3846,7 @@ static void VM_CL_skel_get_bonerel(void)
 }
 
 // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
-static void VM_CL_skel_get_boneabs(void)
+static void VM_CL_skel_get_boneabs(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3932,7 +3877,7 @@ static void VM_CL_skel_get_boneabs(void)
 }
 
 // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
-static void VM_CL_skel_set_bone(void)
+static void VM_CL_skel_set_bone(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3952,7 +3897,7 @@ static void VM_CL_skel_set_bone(void)
 }
 
 // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
-static void VM_CL_skel_mul_bone(void)
+static void VM_CL_skel_mul_bone(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -3974,7 +3919,7 @@ static void VM_CL_skel_mul_bone(void)
 }
 
 // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
-static void VM_CL_skel_mul_bones(void)
+static void VM_CL_skel_mul_bones(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int firstbone = PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -4001,7 +3946,7 @@ static void VM_CL_skel_mul_bones(void)
 }
 
 // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
-static void VM_CL_skel_copybones(void)
+static void VM_CL_skel_copybones(prvm_prog_t *prog)
 {
        int skeletonindexdst = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        int skeletonindexsrc = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
@@ -4022,7 +3967,7 @@ static void VM_CL_skel_copybones(void)
 }
 
 // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
-static void VM_CL_skel_delete(void)
+static void VM_CL_skel_delete(prvm_prog_t *prog)
 {
        int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
        skeleton_t *skeleton;
@@ -4033,7 +3978,7 @@ static void VM_CL_skel_delete(void)
 }
 
 // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
-static void VM_CL_frameforname(void)
+static void VM_CL_frameforname(prvm_prog_t *prog)
 {
        int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
        dp_model_t *model = CL_GetModelByIndex(modelindex);
@@ -4053,7 +3998,7 @@ static void VM_CL_frameforname(void)
 }
 
 // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
-static void VM_CL_frameduration(void)
+static void VM_CL_frameduration(prvm_prog_t *prog)
 {
        int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
        dp_model_t *model = CL_GetModelByIndex(modelindex);
@@ -4065,7 +4010,7 @@ static void VM_CL_frameduration(void)
                PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
 }
 
-void VM_CL_RotateMoves(void)
+static void VM_CL_RotateMoves(prvm_prog_t *prog)
 {
        /*
         * Obscure builtin used by GAME_XONOTIC.
@@ -4104,7 +4049,7 @@ void VM_CL_RotateMoves(void)
 }
 
 // #358 void(string cubemapname) loadcubemap
-static void VM_CL_loadcubemap(void)
+static void VM_CL_loadcubemap(prvm_prog_t *prog)
 {
        const char *name;
 
@@ -4772,9 +4717,9 @@ NULL,                                                     // #640
 
 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
 
-void VM_Polygons_Reset(void)
+void VM_Polygons_Reset(prvm_prog_t *prog)
 {
-       vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
+       vmpolygons_t *polys = &prog->vmpolygons;
 
        // TODO: replace vm_polygons stuff with a more general debugging polygon system, and make vm_polygons functions use that system
        if(polys->initialized)
@@ -4784,17 +4729,15 @@ void VM_Polygons_Reset(void)
        }
 }
 
-void VM_CL_Cmd_Init(void)
+void CLVM_init_cmd(prvm_prog_t *prog)
 {
-       VM_Cmd_Init();
-       VM_Polygons_Reset();
+       VM_Cmd_Init(prog);
+       VM_Polygons_Reset(prog);
 }
 
-void VM_CL_Cmd_Reset(void)
+void CLVM_reset_cmd(prvm_prog_t *prog)
 {
        World_End(&cl.world);
-       VM_Cmd_Reset();
-       VM_Polygons_Reset();
+       VM_Cmd_Reset(prog);
+       VM_Polygons_Reset(prog);
 }
-
-
index 8835dae..259991f 100644 (file)
@@ -1,10 +1,6 @@
 #ifndef __CLVM_CMDS_H__
 #define __CLVM_CMDS_H__
 
-int CL_GetPitchSign(prvm_edict_t *ent);
-int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex);
-void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix);
-
 /* These are VM built-ins that originate in the client-side programs support
    but are reused by the other programs (usually the menu). */
 
@@ -23,8 +19,6 @@ void VM_CL_R_LoadWorldModel (void);
 void VM_CL_R_PolygonBegin (void);
 void VM_CL_R_PolygonVertex (void);
 void VM_CL_R_PolygonEnd (void);
-/* VMs exposing the polygon calls must call this on Init/Reset */
-void VM_Polygons_Reset(void);
 
&