va_end(argptr);
Con_Print(msg);
- PRVM_PrintState();
+ // 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();
}
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;
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;
}
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" );
if (developer.integer >= 1)
- PRVM_PrintState();
+ VM_Warning( "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" );
if (developer.integer >= 1)
- PRVM_PrintState();
+ VM_Warning( "VM_remove: tried to remove an already freed entity!\n" );
}
else
PRVM_ED_Free (ed);
*/
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);
}
/*
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
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)
{
PRVM_G_FLOAT(OFS_RETURN) = -2;
- VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
+ 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);
}
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)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
- if (developer.integer >= 10)
+ if (developer.integer >= 100)
VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
}
else
{
PRVM_G_FLOAT(OFS_RETURN) = filenum;
- if (developer.integer >= 10)
- VM_Warning("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, 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)
{
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)
{
VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
- FS_Close(VM_FILES[filenum]);
- VM_FILES[filenum] = NULL;
- if (developer.integer >= 10)
- VM_Warning("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
+ FS_Close(prog->openfiles[filenum]);
+ prog->openfiles[filenum] = NULL;
+ if (developer.integer >= 100)
+ Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
}
/*
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)
{
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)
{
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)
{
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)
{
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);
}
{
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);
}
/*
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;
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)
{
PRVM_G_FLOAT(OFS_RETURN) = -2;
- VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
+ 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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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);
}
tmp = VM_GetTempString();
- strcpy(tmp, Key_KeynumToString(keynum));
+ strlcpy(tmp, Key_KeynumToString(keynum), VM_STRINGTEMP_LENGTH);
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
}
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;
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))
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 );
}
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])
{
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);
}
}
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);
int bufindex, strindex;
qcstrbuffer_t *b;
const char *news;
+ size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_set);
}
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);
}
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;
}
projects / xonotic / darkplaces.git / blobdiff