#include "prvm_cmds.h"
+// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
+void VM_Warning(const char *fmt, ...)
+{
+ va_list argptr;
+ char msg[MAX_INPUTLINE];
+
+ va_start(argptr,fmt);
+ dpvsnprintf(msg,sizeof(msg),fmt,argptr);
+ va_end(argptr);
+
+ Con_Print(msg);
+ // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
+ //PRVM_PrintState();
+}
+
+
//============================================================================
// Common
static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH];
static int vm_string_tempindex = 0;
-// qc file handling
-#define MAX_VMFILES 256
-#define MAX_PRVMFILES MAX_VMFILES * PRVM_MAXPROGS
-#define VM_FILES ((qfile_t**)(vm_files + PRVM_GetProgNr() * MAX_VMFILES))
-
-qfile_t *vm_files[MAX_PRVMFILES];
-
-// qc fs search handling
-#define MAX_VMSEARCHES 128
-#define TOTAL_VMSEARCHES MAX_VMSEARCHES * PRVM_MAXPROGS
-#define VM_SEARCHLIST ((fssearch_t**)(vm_fssearchlist + PRVM_GetProgNr() * MAX_VMSEARCHES))
-
-fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
-
+// TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct)
+// TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black]
char *VM_GetTempString(void)
{
char *s;
PRVM_ED_Print(ed);
}
- PRVM_ERROR ("%s: Program error in function %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
}
/*
char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
- Con_Printf("======OBJECT ERROR======\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
if(prog->self)
{
ed = PRVM_G_EDICT (prog->self->ofs);
else
// objerror has to display the object fields -> else call
PRVM_ERROR ("VM_objecterror: self not defined !");
- Con_Printf("%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
}
/*
if(!sv.active)
{
- Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
+ VM_Warning("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
return;
}
clientnum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
{
- Con_Printf("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
+ VM_Warning("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
return;
}
if(!S_LocalSound (s))
{
- Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
return;
}
cvar_string = Cvar_VariableString(name);
- strcpy(out, cvar_string);
+ strlcpy(out, cvar_string, VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out);
}
cvar_string = Cvar_VariableDefString(name);
- strcpy(out, cvar_string);
+ strlcpy(out, cvar_string, VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out);
}
/*
========================
-VM_itoe
+VM_ftoe
-intt ftoi(float num)
+entity ftoe(float num)
========================
*/
-void VM_ftoi(void)
+void VM_ftoe(void)
{
int ent;
- VM_SAFEPARMCOUNT(1, VM_ftoi);
+ VM_SAFEPARMCOUNT(1, VM_ftoe);
ent = (int)PRVM_G_FLOAT(OFS_PARM0);
- if(PRVM_PROG_TO_EDICT(ent)->priv.required->free)
- PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!", PRVM_NAME, ent);
+ if (ent < 0 || ent >= MAX_EDICTS || PRVM_PROG_TO_EDICT(ent)->priv.required->free)
+ ent = 0; // return world instead of a free or invalid entity
PRVM_G_INT(OFS_RETURN) = ent;
}
VM_SAFEPARMCOUNT(1, VM_remove);
ed = PRVM_G_EDICT(OFS_PARM0);
- if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) {
- Con_DPrint( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
- } else if( ed->priv.required->free ) {
- Con_DPrint( "VM_remove: tried to remove an already freed entity!\n" );
- } else {
- PRVM_ED_Free (ed);
+ if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
+ {
+ if (developer.integer >= 1)
+ VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
+ }
+ else if( ed->priv.required->free )
+ {
+ if (developer.integer >= 1)
+ VM_Warning( "VM_remove: tried to remove an already freed entity!\n" );
}
+ else
+ PRVM_ED_Free (ed);
// if (ed == prog->edicts)
// PRVM_ERROR ("remove: tried to remove world");
// if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
*/
void VM_rint (void)
{
- float f;
-
+ float f;
VM_SAFEPARMCOUNT(1,VM_rint);
f = PRVM_G_FLOAT(OFS_PARM0);
if (f > 0)
- PRVM_G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
+ PRVM_G_FLOAT(OFS_RETURN) = floor(f + 0.5);
else
- PRVM_G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
+ PRVM_G_FLOAT(OFS_RETURN) = ceil(f - 0.5);
}
/*
if(!sv.active)
{
- Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
+ VM_Warning("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
return;
}
PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
}
+/*
+=========
+VM_asin
+
+float asin(float)
+=========
+*/
+void VM_asin (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_asin);
+ PRVM_G_FLOAT(OFS_RETURN) = asin(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_acos
+float acos(float)
+=========
+*/
+void VM_acos (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_acos);
+ PRVM_G_FLOAT(OFS_RETURN) = acos(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_atan
+float atan(float)
+=========
+*/
+void VM_atan (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_atan);
+ PRVM_G_FLOAT(OFS_RETURN) = atan(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_atan2
+float atan2(float,float)
+=========
+*/
+void VM_atan2 (void)
+{
+ VM_SAFEPARMCOUNT(2,VM_atan2);
+ PRVM_G_FLOAT(OFS_RETURN) = atan2(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
+}
+
+/*
+=========
+VM_tan
+float tan(float)
+=========
+*/
+void VM_tan (void)
+{
+ VM_SAFEPARMCOUNT(1,VM_tan);
+ PRVM_G_FLOAT(OFS_RETURN) = tan(PRVM_G_FLOAT(OFS_PARM0));
+}
+
/*
=================
VM_randomvec
// check for overlap with a command
if (Cmd_Exists (name))
{
- Con_Printf("VM_registercvar: %s is a command\n", name);
+ VM_Warning("VM_registercvar: %s is a command\n", name);
return;
}
void VM_Files_Init(void)
{
- memset(VM_FILES, 0, sizeof(qfile_t*[MAX_VMFILES]));
+ int i;
+ for (i = 0;i < PRVM_MAX_OPENFILES;i++)
+ prog->openfiles[i] = NULL;
}
void VM_Files_CloseAll(void)
{
int i;
- for (i = 0;i < MAX_VMFILES;i++)
+ for (i = 0;i < PRVM_MAX_OPENFILES;i++)
{
- if (VM_FILES[i])
- FS_Close(VM_FILES[i]);
- //VM_FILES[i] = NULL;
+ if (prog->openfiles[i])
+ FS_Close(prog->openfiles[i]);
+ prog->openfiles[i] = NULL;
}
- memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?)
}
qfile_t *VM_GetFileHandle( int index )
{
- if (index < 0 || index >= MAX_VMFILES)
+ if (index < 0 || index >= PRVM_MAX_OPENFILES)
{
Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, PRVM_NAME);
return NULL;
}
- if (VM_FILES[index] == NULL)
+ if (prog->openfiles[index] == NULL)
{
Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME);
return NULL;
}
- return VM_FILES[index];
+ return prog->openfiles[index];
}
/*
VM_SAFEPARMCOUNT(2,VM_fopen);
- for (filenum = 0;filenum < MAX_VMFILES;filenum++)
- if (VM_FILES[filenum] == NULL)
+ for (filenum = 0;filenum < PRVM_MAX_OPENFILES;filenum++)
+ if (prog->openfiles[filenum] == NULL)
break;
- if (filenum >= MAX_VMFILES)
+ if (filenum >= PRVM_MAX_OPENFILES)
{
- Con_Printf("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
return;
}
mode = (int)PRVM_G_FLOAT(OFS_PARM1);
modestring = "wb";
break;
default:
- Con_Printf("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
return;
}
filename = PRVM_G_STRING(OFS_PARM0);
- VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
- if (VM_FILES[filenum] == NULL && mode == 0)
- VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false, false);
+ prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
+ if (prog->openfiles[filenum] == NULL && mode == 0)
+ prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false);
- if (VM_FILES[filenum] == NULL)
+ if (prog->openfiles[filenum] == NULL)
{
- if (developer.integer >= 10)
- Con_Printf("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ if (developer.integer >= 100)
+ VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
}
else
{
- if (developer.integer >= 10)
- Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
PRVM_G_FLOAT(OFS_RETURN) = filenum;
+ if (developer.integer >= 100)
+ Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
}
}
VM_SAFEPARMCOUNT(1,VM_fclose);
filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
- if (filenum < 0 || filenum >= MAX_VMFILES)
+ if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
{
- Con_Printf("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
return;
}
- if (VM_FILES[filenum] == NULL)
+ if (prog->openfiles[filenum] == NULL)
{
- Con_Printf("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
- if (developer.integer >= 10)
+ FS_Close(prog->openfiles[filenum]);
+ prog->openfiles[filenum] = NULL;
+ if (developer.integer >= 100)
Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
- FS_Close(VM_FILES[filenum]);
- VM_FILES[filenum] = NULL;
}
/*
VM_SAFEPARMCOUNT(1,VM_fgets);
filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
- if (filenum < 0 || filenum >= MAX_VMFILES)
+ if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
{
- Con_Printf("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
return;
}
- if (VM_FILES[filenum] == NULL)
+ if (prog->openfiles[filenum] == NULL)
{
- Con_Printf("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
end = 0;
for (;;)
{
- c = FS_Getc(VM_FILES[filenum]);
+ c = FS_Getc(prog->openfiles[filenum]);
if (c == '\r' || c == '\n' || c < 0)
break;
if (end < VM_STRINGTEMP_LENGTH - 1)
// remove \n following \r
if (c == '\r')
{
- c = FS_Getc(VM_FILES[filenum]);
+ c = FS_Getc(prog->openfiles[filenum]);
if (c != '\n')
- FS_UnGetc(VM_FILES[filenum], (unsigned char)c);
+ FS_UnGetc(prog->openfiles[filenum], (unsigned char)c);
}
if (developer.integer >= 100)
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
VM_SAFEPARMCOUNT(2,VM_fputs);
filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
- if (filenum < 0 || filenum >= MAX_VMFILES)
+ if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
{
- Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
return;
}
- if (VM_FILES[filenum] == NULL)
+ if (prog->openfiles[filenum] == NULL)
{
- Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
VM_VarString(1, string, sizeof(string));
if ((stringlength = (int)strlen(string)))
- FS_Write(VM_FILES[filenum], string, stringlength);
+ FS_Write(prog->openfiles[filenum], string, stringlength);
if (developer.integer >= 100)
Con_Printf("fputs: %s: %s\n", PRVM_NAME, string);
}
PRVM_G_FLOAT(OFS_RETURN) = 0;
}
+// DRESK - Decolorized String
+/*
+=========
+VM_strdecolorize
+
+string strdecolorize(string s)
+=========
+*/
+// string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped
+void VM_strdecolorize(void)
+{
+ char *szNewString;
+ const char *szString;
+ size_t nCnt;
+ int nPos;
+ int nFillPos;
+ int bFinished;
+ nPos = 0;
+ nFillPos = 0;
+ nCnt = 0;
+ bFinished = 0;
+
+ // Prepare Strings
+ VM_SAFEPARMCOUNT(1,VM_strdecolorize);
+ szString = PRVM_G_STRING(OFS_PARM0);
+ szNewString = VM_GetTempString();
+
+ while(!bFinished)
+ { // Traverse through String
+ if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0)
+ { // String End Found
+ szNewString[nFillPos++] = szString[nPos];
+ bFinished = 1;
+ }
+ else
+ if( szString[nPos] == STRING_COLOR_TAG)
+ { // Color Code Located
+ if( szString[nPos + 1] == STRING_COLOR_TAG)
+ { // Valid Characters to Include
+ szNewString[nFillPos++] = szString[nPos];
+ nPos = nPos + 1;
+ szNewString[nFillPos++] = szString[nPos];
+ }
+ else
+ if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' )
+ { // Color Code Found; Increment Position
+ nPos = nPos + 1;
+ }
+ else
+ { // Unknown Color Code; Include
+ szNewString[nFillPos++] = szString[nPos];
+ nPos = nPos + 1;
+ }
+ }
+ else
+ // Include Character
+ szNewString[nFillPos++] = szString[nPos];
+
+ // Increment Position
+ nPos = nPos + 1;
+ }
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(szNewString);
+}
+
+// DRESK - String Length (not counting color codes)
+/*
+=========
+VM_strlennocol
+
+float strlennocol(string s)
+=========
+*/
+// float(string s) strlennocol = #471; // returns how many characters are in a string not including color codes
+// For example, ^2Dresk returns a length of 5
+void VM_strlennocol(void)
+{
+ const char *szString;
+ size_t nCnt;
+ int nPos;
+ int bFinished;
+ nPos = 0;
+ nCnt = 0;
+ bFinished = 0;
+
+ VM_SAFEPARMCOUNT(1,VM_strlennocol);
+
+ szString = PRVM_G_STRING(OFS_PARM0);
+ if(szString)
+ { // Valid String
+ while(!bFinished)
+ { // Count Characters
+ // SV_BroadcastPrintf("Position '%d'; Character '%c'; Length '%d'\n", nPos, szString[nPos], nCnt);
+
+ if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0)
+ { // String End Found
+ // SV_BroadcastPrintf("Found End of String at '%d'\n", nPos);
+ bFinished = 1;
+ }
+ else
+ if( szString[nPos] == STRING_COLOR_TAG)
+ { // Color Code Located
+ if( szString[nPos + 1] == STRING_COLOR_TAG)
+ { // Increment Length; Skip Color Code
+ nCnt = nCnt + 1;
+ nPos = nPos + 1;
+ }
+ else
+ if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' )
+ { // Color Code Found; Increment Position
+ // SV_BroadcastPrintf("Found Color Codes at '%d'\n", nPos);
+ nPos = nPos + 1;
+ }
+ else
+ { // Unknown Color Code; Increment Length!
+ nPos = nPos + 1;
+ nCnt = nCnt + 1;
+ }
+ }
+ else
+ // Increment String Length
+ nCnt = nCnt + 1;
+
+ // Increment Position
+ nPos = nPos + 1;
+ }
+ PRVM_G_FLOAT(OFS_RETURN) = nCnt;
+ }
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+}
+
/*
=========
VM_strcat
{
char *out;
char string[VM_STRINGTEMP_LENGTH];
+ size_t alloclen;
VM_SAFEPARMCOUNT(1,VM_strzone);
VM_VarString(0, string, sizeof(string));
- PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(strlen(string) + 1, &out);
- strcpy(out, string);
+ alloclen = strlen(string) + 1;
+ PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(alloclen, &out);
+ memcpy(out, string, alloclen);
}
/*
i = (int)PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
{
- Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
+ VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
return;
}
pos = 0;
while(COM_ParseToken(&p, false))
{
+ size_t tokenlen;
if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
break;
- if (pos + strlen(com_token) + 1 > sizeof(tokenbuf))
+ tokenlen = strlen(com_token) + 1;
+ if (pos + tokenlen > sizeof(tokenbuf))
break;
tokens[num_tokens++] = tokenbuf + pos;
- strcpy(tokenbuf + pos, com_token);
- pos += strlen(com_token) + 1;
+ memcpy(tokenbuf + pos, com_token, tokenlen);
+ pos += tokenlen;
}
PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
OS_MAC - not supported
*/
-#ifdef _WIN32
+#ifdef WIN32
PRVM_G_FLOAT(OFS_RETURN) = 0;
-#elif defined _MAC
+#elif defined(MACOSX)
PRVM_G_FLOAT(OFS_RETURN) = 2;
#else
PRVM_G_FLOAT(OFS_RETURN) = 1;
data = PRVM_G_STRING(OFS_PARM1);
// parse the opening brace
- if (!COM_ParseToken(&data, false) || com_token[0] != '{' )
+ if (!COM_ParseTokenConsole(&data) || com_token[0] != '{' )
PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
PRVM_ED_ParseEdict (data, ent);
// \ is a windows-ism (so it's naughty to use it, / works on all platforms)
if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
{
- Con_Printf("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
return;
}
void VM_Search_Init(void)
{
- memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+ int i;
+ for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++)
+ prog->opensearches[i] = NULL;
}
void VM_Search_Reset(void)
{
int i;
// reset the fssearch list
- for(i = 0; i < MAX_VMSEARCHES; i++)
- if(VM_SEARCHLIST[i])
- FS_FreeSearch(VM_SEARCHLIST[i]);
- memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+ for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++)
+ {
+ if(prog->opensearches[i])
+ FS_FreeSearch(prog->opensearches[i]);
+ prog->opensearches[i] = NULL;
+ }
}
/*
caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
- for(handle = 0; handle < MAX_VMSEARCHES; handle++)
- if(!VM_SEARCHLIST[handle])
+ for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++)
+ if(!prog->opensearches[handle])
break;
- if(handle >= MAX_VMSEARCHES)
+ if(handle >= PRVM_MAX_OPENSEARCHES)
{
- Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENSEARCHES);
return;
}
- if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet)))
+ if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
PRVM_G_FLOAT(OFS_RETURN) = -1;
else
PRVM_G_FLOAT(OFS_RETURN) = handle;
handle = (int)PRVM_G_FLOAT(OFS_PARM0);
- if(handle < 0 || handle >= MAX_VMSEARCHES)
+ if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
{
- Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
- if(VM_SEARCHLIST[handle] == NULL)
+ if(prog->opensearches[handle] == NULL)
{
- Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
- FS_FreeSearch(VM_SEARCHLIST[handle]);
- VM_SEARCHLIST[handle] = NULL;
+ FS_FreeSearch(prog->opensearches[handle]);
+ prog->opensearches[handle] = NULL;
}
/*
handle = (int)PRVM_G_FLOAT(OFS_PARM0);
- if(handle < 0 || handle >= MAX_VMSEARCHES)
+ if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
{
- Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
- if(VM_SEARCHLIST[handle] == NULL)
+ if(prog->opensearches[handle] == NULL)
{
- Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
- PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames;
+ PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames;
}
/*
handle = (int)PRVM_G_FLOAT(OFS_PARM0);
filenum = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(handle < 0 || handle >= MAX_VMSEARCHES)
+ if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
{
- Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
- if(VM_SEARCHLIST[handle] == NULL)
+ if(prog->opensearches[handle] == NULL)
{
- Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
- if(filenum < 0 || filenum >= VM_SEARCHLIST[handle]->numfilenames)
+ if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames)
{
- Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
return;
}
tmp = VM_GetTempString();
- strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]);
+ strlcpy(tmp, prog->opensearches[handle]->filenames[filenum], VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
s = PRVM_G_STRING(OFS_PARM0);
if(!s)
- PRVM_ERROR ("VM_freepic: %s: NULL");
+ PRVM_ERROR ("VM_freepic: NULL");
VM_CheckEmptyString (s);
character = (char) PRVM_G_FLOAT(OFS_PARM1);
if(character == 0)
{
- Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(!scale[0] || !scale[1])
{
- Con_Printf("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
return;
}
string = PRVM_G_STRING(OFS_PARM1);
if(!string)
{
- Con_Printf("VM_drawstring: %s passed null string !\n",PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawstring: %s passed null string !\n",PRVM_NAME);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(!scale[0] || !scale[1])
{
- Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
return;
}
if(pos[2] || scale[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+ Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
if(!picname)
{
- Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
return;
}
// is pic cached ? no function yet for that
if(!1)
{
- Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+ Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawfill: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(pos[2] || size[2])
- Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+ Con_Printf("VM_drawfill: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
DrawQ_Pic(pos[0], pos[1], NULL, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
tmp = VM_GetTempString();
- strcpy(tmp, Key_KeynumToString(keynum));
+ strlcpy(tmp, Key_KeynumToString(keynum), VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
VM_InitPolygons();
if(vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonBegin: called twice without VM_R_PolygonEnd after first\n");
+ VM_Warning("VM_R_PolygonBegin: called twice without VM_R_PolygonEnd after first\n");
return;
}
if(vm_drawpolygons_num >= vm_polygons_num)
if(picname[0])
p->tex = Draw_CachePic(picname, true)->tex;
else
- p->tex = r_texture_notexture;
+ p->tex = r_texture_white;
p->flags = (unsigned char)PRVM_G_FLOAT(OFS_PARM1);
vm_current_vertices = 0;
vm_polygonbegin = true;
if(!vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonVertex: VM_R_PolygonBegin wasn't called\n");
+ VM_Warning("VM_R_PolygonVertex: VM_R_PolygonBegin wasn't called\n");
return;
}
coords = PRVM_G_VECTOR(OFS_PARM0);
p = &vm_polygons[vm_drawpolygons_num];
if(vm_current_vertices > 4)
{
- Con_Printf("VM_R_PolygonVertex: may have 4 vertices max\n");
+ VM_Warning("VM_R_PolygonVertex: may have 4 vertices max\n");
return;
}
p->data[vm_current_vertices*3] = coords[0];
p->data[1+vm_current_vertices*3] = coords[1];
- if(!(p->flags & VM_POLYGON_FL2D))
- p->data[2+vm_current_vertices*3] = coords[2];
+ p->data[2+vm_current_vertices*3] = coords[2];
p->data[12+vm_current_vertices*2] = tx[0];
if(!(p->flags & VM_POLYGON_FLLINES))
{
if(!vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonEnd: VM_R_PolygonBegin wasn't called\n");
+ VM_Warning("VM_R_PolygonEnd: VM_R_PolygonBegin wasn't called\n");
return;
}
+ vm_polygonbegin = false;
if(vm_current_vertices > 2 || (vm_current_vertices >= 2 && vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FLLINES))
{
if(vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FL2D) //[515]: don't use qcpolygons memory if 2D
vm_drawpolygons_num++;
}
else
- Con_Printf("VM_R_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices);
- vm_polygonbegin = false;
+ VM_Warning("VM_R_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices);
}
void VM_AddPolygonsToMeshQueue (void)
return;
}
- strcpy( out, in );
+ strlcpy(out, in, VM_STRINGTEMP_LENGTH);
PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
}
for( ; *set ; *out++ = *set++ );
*out++ = '\'';
- strcpy( out, in );
+ strlcpy(out, in, VM_STRINGTEMP_LENGTH);
PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
}
BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
else
{
- Con_Printf("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
}
if(!b)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
- Con_Printf("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
else
b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b1)
{
- Con_Printf("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
i = (int)PRVM_G_FLOAT(OFS_PARM1);
if(i == (int)PRVM_G_FLOAT(OFS_PARM0))
{
- Con_Printf("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
+ VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
return;
}
b2 = BUFSTR_BUFFER(i);
if(!b2)
{
- Con_Printf("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+ VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
return;
}
for(i=0;i<b1->num_strings;i++)
if(b1->strings[i] && b1->strings[i][0])
{
- b2->strings[i] = (char *)Z_Malloc(strlen(b1->strings[i])+1);
+ size_t stringlen;
+ stringlen = strlen(b1->strings[i]) + 1;
+ b2->strings[i] = (char *)Z_Malloc(stringlen);
if(!b2->strings[i])
{
- Con_Printf("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+ VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
break;
}
- strcpy(b2->strings[i], b1->strings[i]);
+ memcpy(b2->strings[i], b1->strings[i], stringlen);
}
}
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
if(b->num_strings <= 0)
{
- Con_Printf("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
PRVM_G_INT(OFS_RETURN) = 0;
if(!b)
{
- Con_Printf("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
if(!b->num_strings)
l += strlen(b->strings[i]);
if(l>=4095)
break;
- k = strcat(k, b->strings[i]);
- if(!k)
- break;
+ strlcat(k, b->strings[i], VM_STRINGTEMP_LENGTH);
if(sep && (i != b->num_strings-1))
{
l += strlen(sep);
if(l>=4095)
break;
- k = strcat(k, sep);
- if(!k)
- break;
+ strlcat(k, sep, VM_STRINGTEMP_LENGTH);
}
}
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(k);
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
PRVM_G_INT(OFS_RETURN) = 0;
int bufindex, strindex;
qcstrbuffer_t *b;
const char *news;
+ size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_set);
b = BUFSTR_BUFFER(bufindex);
if(!b)
{
- Con_Printf("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
news = PRVM_G_STRING(OFS_PARM2);
if(!news)
{
- Con_Printf("VM_bufstr_set: null string used in %s\n", PRVM_NAME);
+ VM_Warning("VM_bufstr_set: null string used in %s\n", PRVM_NAME);
return;
}
if(b->strings[strindex])
Z_Free(b->strings[strindex]);
- b->strings[strindex] = (char *)Z_Malloc(strlen(news)+1);
- strcpy(b->strings[strindex], news);
+ alloclen = strlen(news) + 1;
+ b->strings[strindex] = (char *)Z_Malloc(alloclen);
+ memcpy(b->strings[strindex], news, alloclen);
}
/*
int bufindex, order, strindex;
qcstrbuffer_t *b;
const char *string;
+ size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_add);
PRVM_G_FLOAT(OFS_RETURN) = -1;
if(!b)
{
- Con_Printf("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
return;
}
string = PRVM_G_STRING(OFS_PARM1);
if(!string)
{
- Con_Printf("VM_bufstr_add: null string used in %s\n", PRVM_NAME);
+ VM_Warning("VM_bufstr_add: null string used in %s\n", PRVM_NAME);
return;
}
strindex = BufStr_FindFreeString(b);
if(strindex < 0)
{
- Con_Printf("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
return;
}
}
{
if(b->num_strings == MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
return;
}
b->strings[b->num_strings] = NULL;
}
if(b->strings[strindex])
Z_Free(b->strings[strindex]);
- b->strings[strindex] = (char *)Z_Malloc(strlen(string)+1);
- strcpy(b->strings[strindex], string);
+ alloclen = strlen(string) + 1;
+ b->strings[strindex] = (char *)Z_Malloc(alloclen);
+ memcpy(b->strings[strindex], string, alloclen);
PRVM_G_FLOAT(OFS_RETURN) = strindex;
}
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
i = (int)PRVM_G_FLOAT(OFS_PARM1);
if(i < 0 || i > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
+ VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
return;
}
if(b->strings[i])
projects / xonotic / darkplaces.git / blobdiff