X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=4a5bcd0b923d90fa038011808927549add1dad28;hp=4fe245f2c33c251ab8a8af8d479384296716676b;hb=7fe21433f8c26bd2442ab72707f7f6063c1932e7;hpb=176db0d8c03f85c51f9afdb7f8478ad89cb91aa8 diff --git a/prvm_cmds.c b/prvm_cmds.c index 4fe245f2..4a5bcd0b 100644 --- a/prvm_cmds.c +++ b/prvm_cmds.c @@ -5,36 +5,31 @@ // also applies here #include "prvm_cmds.h" +#include -//============================================================================ -// Common - -// temp string handling -// LordHavoc: added this to semi-fix the problem of using many ftos calls in a print -static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH]; -static int vm_string_tempindex = 0; +// 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]; -// 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)) + va_start(argptr,fmt); + dpvsnprintf(msg,sizeof(msg),fmt,argptr); + va_end(argptr); -qfile_t *vm_files[MAX_PRVMFILES]; + 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(); +} -// 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]; +//============================================================================ +// Common -char *VM_GetTempString(void) -{ - char *s; - s = vm_string_temp[vm_string_tempindex]; - vm_string_tempindex = (vm_string_tempindex + 1) % VM_STRINGTEMP_BUFFERS; - return s; -} +// TODO DONE: move vm_files and vm_fssearchlist to prvm_prog_t struct +// TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black] +// TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct again) [2007-01-23 LordHavoc] +// TODO: will this war ever end? [2007-01-23 LordHavoc] void VM_CheckEmptyString (const char *s) { @@ -123,7 +118,7 @@ void VM_error (void) 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); } /* @@ -142,7 +137,7 @@ void VM_objerror (void) 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); @@ -153,16 +148,16 @@ void VM_objerror (void) 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); } /* ================= -VM_print (actually used only by client and menu) +VM_print print to console -print(string) +print(...[string]) ================= */ void VM_print (void) @@ -188,7 +183,7 @@ void VM_bprint (void) 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; } @@ -212,10 +207,10 @@ void VM_sprint (void) char string[VM_STRINGTEMP_LENGTH]; //find client for this entity - clientnum = PRVM_G_FLOAT(OFS_PARM0); + 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; } @@ -442,8 +437,8 @@ void VM_localsound(void) 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; } @@ -504,25 +499,14 @@ const string VM_cvar_string (string) */ void VM_cvar_string(void) { - char *out; const char *name; - const char *cvar_string; VM_SAFEPARMCOUNT(1,VM_cvar_string); name = PRVM_G_STRING(OFS_PARM0); - if(!name) - PRVM_ERROR("VM_cvar_string: %s: null string", PRVM_NAME); - VM_CheckEmptyString(name); - out = VM_GetTempString(); - - cvar_string = Cvar_VariableString(name); - - strcpy(out, cvar_string); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(name)); } @@ -535,25 +519,14 @@ const string VM_cvar_defstring (string) */ void VM_cvar_defstring (void) { - char *out; const char *name; - const char *cvar_string; VM_SAFEPARMCOUNT(1,VM_cvar_string); name = PRVM_G_STRING(OFS_PARM0); - if(!name) - PRVM_ERROR("VM_cvar_defstring: %s: null string", PRVM_NAME); - VM_CheckEmptyString(name); - out = VM_GetTempString(); - - cvar_string = Cvar_VariableDefString(name); - - strcpy(out, cvar_string); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(name)); } /* ================= @@ -601,18 +574,17 @@ string ftos(float) void VM_ftos (void) { float v; - char *s; + char s[128]; VM_SAFEPARMCOUNT(1, VM_ftos); v = PRVM_G_FLOAT(OFS_PARM0); - s = VM_GetTempString(); if ((float)((int)v) == v) sprintf(s, "%i", (int)v); else sprintf(s, "%f", v); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -643,13 +615,12 @@ string vtos(vector) void VM_vtos (void) { - char *s; + char s[512]; VM_SAFEPARMCOUNT(1,VM_vtos); - s = VM_GetTempString(); sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -662,13 +633,12 @@ string etos(entity) void VM_etos (void) { - char *s; + char s[128]; VM_SAFEPARMCOUNT(1, VM_etos); - s = VM_GetTempString(); sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0)); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -700,23 +670,51 @@ void VM_itof(void) /* ======================== -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 = 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); + ent = (int)PRVM_G_FLOAT(OFS_PARM0); + 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_strftime + +string strftime(float uselocaltime, string[, string ...]) +========= +*/ +void VM_strftime(void) +{ + time_t t; + struct tm *tm; + char fmt[VM_STRINGTEMP_LENGTH]; + char result[VM_STRINGTEMP_LENGTH]; + VM_VarString(0, fmt, sizeof(fmt)); + t = time(NULL); + if (PRVM_G_FLOAT(OFS_PARM0)) + tm = localtime(&t); + else + tm = gmtime(&t); + if (!tm) + { + PRVM_G_FLOAT(OFS_RETURN) = 0; + return; + } + strftime(result, sizeof(result), fmt, tm); + PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result); +} + /* ========= VM_spawn @@ -749,13 +747,18 @@ void VM_remove (void) 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) @@ -783,12 +786,9 @@ void VM_find (void) f = PRVM_G_INT(OFS_PARM1); s = PRVM_G_STRING(OFS_PARM2); - if (!s || !s[0]) - { - // return reserved edict 0 (could be used for whatever the prog wants) - VM_RETURN_EDICT(prog->edicts); - return; - } + // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and + // expects it to find all the monsters, so we must be careful to support + // searching for "" for (e++ ; e < prog->num_edicts ; e++) { @@ -798,7 +798,7 @@ void VM_find (void) continue; t = PRVM_E_STRING(ed,f); if (!t) - continue; + t = ""; if (!strcmp(t,s)) { VM_RETURN_EDICT(ed); @@ -876,11 +876,10 @@ void VM_findchain (void) f = PRVM_G_INT(OFS_PARM0); s = PRVM_G_STRING(OFS_PARM1); - if (!s || !s[0]) - { - VM_RETURN_EDICT(prog->edicts); - return; - } + + // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and + // expects it to find all the monsters, so we must be careful to support + // searching for "" ent = PRVM_NEXT_EDICT(prog->edicts); for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent)) @@ -890,7 +889,7 @@ void VM_findchain (void) continue; t = PRVM_E_STRING(ent,f); if (!t) - continue; + t = ""; if (strcmp(t,s)) continue; @@ -975,6 +974,8 @@ void VM_findflags (void) ed = PRVM_EDICT_NUM(e); if (ed->priv.required->free) continue; + if (!PRVM_E_FLOAT(ed,f)) + continue; if ((int)PRVM_E_FLOAT(ed,f) & s) { VM_RETURN_EDICT(ed); @@ -1019,6 +1020,8 @@ void VM_findchainflags (void) prog->xfunction->builtinsprofile++; if (ent->priv.required->free) continue; + if (!PRVM_E_FLOAT(ent,f)) + continue; if (!((int)PRVM_E_FLOAT(ent,f) & s)) continue; @@ -1126,15 +1129,14 @@ float rint(float) */ 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); } /* @@ -1209,13 +1211,11 @@ changelevel(string map) */ void VM_changelevel (void) { - const char *s; - VM_SAFEPARMCOUNT(1, VM_changelevel); 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; } @@ -1224,8 +1224,7 @@ void VM_changelevel (void) return; svs.changelevel_issued = true; - s = PRVM_G_STRING(OFS_PARM0); - Cbuf_AddText (va("changelevel %s\n",s)); + Cbuf_AddText (va("changelevel %s\n",PRVM_G_STRING(OFS_PARM0))); } /* @@ -1266,6 +1265,67 @@ void VM_sqrt (void) 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 @@ -1320,7 +1380,7 @@ void VM_registercvar (void) name = PRVM_G_STRING(OFS_PARM0); value = PRVM_G_STRING(OFS_PARM1); - flags = PRVM_G_FLOAT(OFS_PARM2); + flags = (int)PRVM_G_FLOAT(OFS_PARM2); PRVM_G_FLOAT(OFS_RETURN) = 0; if(flags > CVAR_MAXFLAGSVAL) @@ -1333,7 +1393,7 @@ void VM_registercvar (void) // 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; } @@ -1482,34 +1542,35 @@ setcolor(clientent, value) 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]; } /* @@ -1529,16 +1590,16 @@ void VM_fopen(void) 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 = PRVM_G_FLOAT(OFS_PARM1); + mode = (int)PRVM_G_FLOAT(OFS_PARM1); switch(mode) { case 0: // FILE_READ @@ -1551,27 +1612,27 @@ void VM_fopen(void) 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) - 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) - 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); } } @@ -1589,21 +1650,21 @@ void VM_fclose(void) VM_SAFEPARMCOUNT(1,VM_fclose); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + 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) + 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; } /* @@ -1617,26 +1678,26 @@ string fgets(float fhandle) void VM_fgets(void) { int c, end; - static char string[VM_STRINGTEMP_LENGTH]; + char string[VM_STRINGTEMP_LENGTH]; int filenum; VM_SAFEPARMCOUNT(1,VM_fgets); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + 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) @@ -1646,16 +1707,16 @@ void VM_fgets(void) // 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 >= 3) + if (developer.integer >= 100) Con_Printf("fgets: %s: %s\n", PRVM_NAME, string); if (c >= 0 || end) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); else - PRVM_G_INT(OFS_RETURN) = 0; + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -1674,21 +1735,21 @@ void VM_fputs(void) VM_SAFEPARMCOUNT(2,VM_fputs); - filenum = PRVM_G_FLOAT(OFS_PARM0); - if (filenum < 0 || filenum >= MAX_VMFILES) + filenum = (int)PRVM_G_FLOAT(OFS_PARM0); + 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); - if (developer.integer) + FS_Write(prog->openfiles[filenum], string, stringlength); + if (developer.integer >= 100) Con_Printf("fputs: %s: %s\n", PRVM_NAME, string); } @@ -1702,15 +1763,136 @@ float strlen(string s) //float(string s) strlen = #114; // returns how many characters are in a string void VM_strlen(void) { - const char *s; - VM_SAFEPARMCOUNT(1,VM_strlen); - s = PRVM_G_STRING(OFS_PARM0); - if (s) - PRVM_G_FLOAT(OFS_RETURN) = strlen(s); - else - PRVM_G_FLOAT(OFS_RETURN) = 0; + PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0)); +} + +// 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[VM_STRINGTEMP_LENGTH]; + 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); + + 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_SetTempString(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); + + 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; } /* @@ -1725,14 +1907,13 @@ string strcat(string,string,...[string]) // and returns as a tempstring void VM_strcat(void) { - char *s; + char s[VM_STRINGTEMP_LENGTH]; if(prog->argc < 1) PRVM_ERROR("VM_strcat wrong parameter count (min. 1 expected ) !"); - s = VM_GetTempString(); - VM_VarString(0, s, VM_STRINGTEMP_LENGTH); - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s); + VM_VarString(0, s, sizeof(s)); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s); } /* @@ -1748,21 +1929,18 @@ void VM_substring(void) { int i, start, length; const char *s; - char *string; + char string[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT(3,VM_substring); - string = VM_GetTempString(); s = PRVM_G_STRING(OFS_PARM0); - start = PRVM_G_FLOAT(OFS_PARM1); - length = PRVM_G_FLOAT(OFS_PARM2); - if (!s) - s = ""; + start = (int)PRVM_G_FLOAT(OFS_PARM1); + length = (int)PRVM_G_FLOAT(OFS_PARM2); for (i = 0;i < start && *s;i++, s++); - for (i = 0;i < VM_STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++) + for (i = 0;i < (int)sizeof(string) - 1 && *s && i < length;i++, s++) string[i] = *s; string[i] = 0; - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string); } /* @@ -1795,12 +1973,14 @@ void VM_strzone(void) { 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); } /* @@ -1833,10 +2013,10 @@ void VM_clcommand (void) VM_SAFEPARMCOUNT(2,VM_clcommand); - i = PRVM_G_FLOAT(OFS_PARM0); + 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; } @@ -1858,27 +2038,35 @@ float tokenize(string s) //this function originally written by KrimZon, made shorter by LordHavoc //20040203: rewritten by LordHavoc (no longer uses allocations) int num_tokens = 0; -char *tokens[256], tokenbuf[MAX_INPUTLINE]; +int tokens[256]; void VM_tokenize (void) { - size_t pos; const char *p; +#if 0 + size_t pos = 0; + char tokenbuf[MAX_INPUTLINE]; + size_t tokenlen; +#endif VM_SAFEPARMCOUNT(1,VM_tokenize); p = PRVM_G_STRING(OFS_PARM0); num_tokens = 0; - pos = 0; while(COM_ParseToken(&p, false)) { if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0]))) break; - if (pos + strlen(com_token) + 1 > sizeof(tokenbuf)) +#if 0 + 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; + tokens[num_tokens++] = PRVM_SetEngineString(tokenbuf + pos); + memcpy(tokenbuf + pos, com_token, tokenlen); + pos += tokenlen; +#else + tokens[num_tokens++] = PRVM_SetTempString(com_token); +#endif } PRVM_G_FLOAT(OFS_RETURN) = num_tokens; @@ -1892,12 +2080,12 @@ void VM_argv (void) VM_SAFEPARMCOUNT(1,VM_argv); - token_num = PRVM_G_FLOAT(OFS_PARM0); + token_num = (int)PRVM_G_FLOAT(OFS_PARM0); if (token_num >= 0 && token_num < num_tokens) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]); + PRVM_G_INT(OFS_RETURN) = tokens[token_num]; else - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -2003,9 +2191,9 @@ void VM_getostype(void) 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; @@ -2079,7 +2267,7 @@ void VM_parseentitydata(void) 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); @@ -2100,14 +2288,10 @@ void VM_loadfromfile(void) VM_SAFEPARMCOUNT(1,VM_loadfromfile); filename = PRVM_G_STRING(OFS_PARM0); - // .. is parent directory on many platforms - // / is parent directory on Amiga - // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea) - // \ 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, '\\')) + if (FS_CheckNastyPath(filename, false)) { - 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; } @@ -2143,17 +2327,21 @@ void VM_modulo(void) 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; + } } /* @@ -2175,21 +2363,21 @@ void VM_search_begin(void) VM_CheckEmptyString(pattern); - caseinsens = PRVM_G_FLOAT(OFS_PARM1); - quiet = PRVM_G_FLOAT(OFS_PARM2); + 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; @@ -2207,21 +2395,21 @@ void VM_search_end(void) int handle; VM_SAFEPARMCOUNT(1, VM_search_end); - handle = PRVM_G_FLOAT(OFS_PARM0); + 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; } /* @@ -2236,20 +2424,20 @@ void VM_search_getsize(void) int handle; VM_SAFEPARMCOUNT(1, VM_M_search_getsize); - handle = PRVM_G_FLOAT(OFS_PARM0); + 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; } /* @@ -2262,32 +2450,28 @@ string search_getfilename(float handle, float num) void VM_search_getfilename(void) { int handle, filenum; - char *tmp; VM_SAFEPARMCOUNT(2, VM_search_getfilename); - handle = PRVM_G_FLOAT(OFS_PARM0); - filenum = PRVM_G_FLOAT(OFS_PARM1); + 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]); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog->opensearches[handle]->filenames[filenum]); } /* @@ -2299,14 +2483,13 @@ string chr(float ascii) */ void VM_chr(void) { - char *tmp; + char tmp[2]; VM_SAFEPARMCOUNT(1, VM_chr); - tmp = VM_GetTempString(); tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0); tmp[1] = 0; - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp); } //============================================================================= @@ -2342,15 +2525,11 @@ void VM_precache_pic(void) s = PRVM_G_STRING(OFS_PARM0); PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0); - - if(!s) - PRVM_ERROR ("VM_precache_pic: %s: NULL", PRVM_NAME); - VM_CheckEmptyString (s); // AK Draw_CachePic is supposed to always return a valid pointer if( Draw_CachePic(s, false)->tex == r_texture_notexture ) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; } /* @@ -2367,10 +2546,6 @@ void VM_freepic(void) VM_SAFEPARMCOUNT(1,VM_freepic); s = PRVM_G_STRING(OFS_PARM0); - - if(!s) - PRVM_ERROR ("VM_freepic: %s: NULL"); - VM_CheckEmptyString (s); Draw_FreePic(s); @@ -2393,8 +2568,8 @@ void VM_drawcharacter(void) 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; } @@ -2405,8 +2580,8 @@ void VM_drawcharacter(void) 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; } @@ -2415,8 +2590,8 @@ void VM_drawcharacter(void) 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; } @@ -2439,15 +2614,6 @@ void VM_drawstring(void) VM_SAFEPARMCOUNT(6,VM_drawstring); 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; - return; - } - - //VM_CheckEmptyString(string); Why should it be checked - perhaps the menu wants to support the precolored letters, too? - pos = PRVM_G_VECTOR(OFS_PARM0); scale = PRVM_G_VECTOR(OFS_PARM2); rgb = PRVM_G_VECTOR(OFS_PARM3); @@ -2455,20 +2621,20 @@ void VM_drawstring(void) 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; @@ -2489,21 +2655,13 @@ void VM_drawpic(void) VM_SAFEPARMCOUNT(6,VM_drawpic); picname = PRVM_G_STRING(OFS_PARM1); - - if(!picname) - { - Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME); - PRVM_G_FLOAT(OFS_RETURN) = -1; - return; - } - VM_CheckEmptyString (picname); // 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; } @@ -2514,13 +2672,13 @@ void VM_drawpic(void) 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; @@ -2548,13 +2706,13 @@ void VM_drawfill(void) 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; @@ -2609,10 +2767,6 @@ void VM_getimagesize(void) VM_SAFEPARMCOUNT(1,VM_getimagesize); p = PRVM_G_STRING(OFS_PARM0); - - if(!p) - PRVM_ERROR("VM_getimagepos: %s passed null picture name !", PRVM_NAME); - VM_CheckEmptyString (p); pic = Draw_CachePic (p, false); @@ -2631,17 +2785,9 @@ string keynumtostring(float keynum) */ void VM_keynumtostring (void) { - int keynum; - char *tmp; VM_SAFEPARMCOUNT(1, VM_keynumtostring); - keynum = PRVM_G_FLOAT(OFS_PARM0); - - tmp = VM_GetTempString(); - - strcpy(tmp, Key_KeynumToString(keynum)); - - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0))); } /* @@ -2653,12 +2799,9 @@ float stringtokeynum(string key) */ void VM_stringtokeynum (void) { - const char *str; VM_SAFEPARMCOUNT( 1, VM_keynumtostring ); - str = PRVM_G_STRING( OFS_PARM0 ); - - PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str ); + PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0)); } // CL_Video interface functions @@ -2811,7 +2954,7 @@ void VM_drawline (void) c2 = PRVM_G_VECTOR(OFS_PARM2); rgb = PRVM_G_VECTOR(OFS_PARM3); alpha = PRVM_G_FLOAT(OFS_PARM4); - flags = PRVM_G_FLOAT(OFS_PARM5); + flags = (int)PRVM_G_FLOAT(OFS_PARM5); DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags); } @@ -2843,79 +2986,88 @@ static qboolean vm_polygonbegin = false; //[515]: for "no-crap-on-the-screen" void VM_InitPolygons (void) { vm_polygons_pool = Mem_AllocPool("VMPOLY", 0, NULL); - vm_polygons = Mem_Alloc(vm_polygons_pool, VM_DEFPOLYNUM*sizeof(vm_polygon_t)); + vm_polygons = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, VM_DEFPOLYNUM*sizeof(vm_polygon_t)); memset(vm_polygons, 0, VM_DEFPOLYNUM*sizeof(vm_polygon_t)); vm_polygons_num = VM_DEFPOLYNUM; - vm_polygonbegin = vm_drawpolygons_num = 0; + vm_drawpolygons_num = 0; + vm_polygonbegin = false; vm_polygons_initialized = true; } -void VM_DrawPolygonCallback (const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) +void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist) { - const vm_polygon_t *p = &vm_polygons[surfacenumber]; - int flags = p->flags & 0x0f; + int surfacelistindex; + // LordHavoc: FIXME: this is stupid code + for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + { + const vm_polygon_t *p = &vm_polygons[surfacelist[surfacelistindex]]; + int flags = p->flags & 0x0f; - if(flags == DRAWFLAG_ADDITIVE) - GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); - else if(flags == DRAWFLAG_MODULATE) - GL_BlendFunc(GL_DST_COLOR, GL_ZERO); - else if(flags == DRAWFLAG_2XMODULATE) - GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR); - else - GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + if(flags == DRAWFLAG_ADDITIVE) + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + else if(flags == DRAWFLAG_MODULATE) + GL_BlendFunc(GL_DST_COLOR, GL_ZERO); + else if(flags == DRAWFLAG_2XMODULATE) + GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR); + else + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - R_Mesh_TexBind(0, R_GetTexture(p->tex)); + R_Mesh_TexBind(0, R_GetTexture(p->tex)); - //[515]: is speed is max ? - if(p->flags & VM_POLYGON_FLLINES) //[515]: lines - { - qglLineWidth(p->data[13]); - qglBegin(GL_LINE_LOOP); - qglTexCoord1f (p->data[12]); - qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]); - qglVertex3f (p->data[0] , p->data[1], p->data[2]); + CHECKGLERROR + //[515]: is speed is max ? + if(p->flags & VM_POLYGON_FLLINES) //[515]: lines + { + qglLineWidth(p->data[13]);CHECKGLERROR + qglBegin(GL_LINE_LOOP); + qglTexCoord1f (p->data[12]); + qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]); + qglVertex3f (p->data[0] , p->data[1], p->data[2]); - qglTexCoord1f (p->data[14]); - qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]); - qglVertex3f (p->data[3] , p->data[4], p->data[5]); + qglTexCoord1f (p->data[14]); + qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]); + qglVertex3f (p->data[3] , p->data[4], p->data[5]); - if(p->flags & VM_POLYGON_FL3V) - { - qglTexCoord1f (p->data[16]); + if(p->flags & VM_POLYGON_FL3V) + { + qglTexCoord1f (p->data[16]); + qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]); + qglVertex3f (p->data[6] , p->data[7], p->data[8]); + + if(p->flags & VM_POLYGON_FL4V) + { + qglTexCoord1f (p->data[18]); + qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]); + qglVertex3f (p->data[9] , p->data[10], p->data[11]); + } + } + qglEnd(); + CHECKGLERROR + } + else + { + qglBegin(GL_POLYGON); + qglTexCoord2f (p->data[12], p->data[13]); + qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]); + qglVertex3f (p->data[0] , p->data[1], p->data[2]); + + qglTexCoord2f (p->data[14], p->data[15]); + qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]); + qglVertex3f (p->data[3] , p->data[4], p->data[5]); + + qglTexCoord2f (p->data[16], p->data[17]); qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]); qglVertex3f (p->data[6] , p->data[7], p->data[8]); if(p->flags & VM_POLYGON_FL4V) { - qglTexCoord1f (p->data[18]); + qglTexCoord2f (p->data[18], p->data[19]); qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]); qglVertex3f (p->data[9] , p->data[10], p->data[11]); } - } - qglEnd(); - } - else - { - qglBegin(GL_POLYGON); - qglTexCoord2f (p->data[12], p->data[13]); - qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]); - qglVertex3f (p->data[0] , p->data[1], p->data[2]); - - qglTexCoord2f (p->data[14], p->data[15]); - qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]); - qglVertex3f (p->data[3] , p->data[4], p->data[5]); - - qglTexCoord2f (p->data[16], p->data[17]); - qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]); - qglVertex3f (p->data[6] , p->data[7], p->data[8]); - - if(p->flags & VM_POLYGON_FL4V) - { - qglTexCoord2f (p->data[18], p->data[19]); - qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]); - qglVertex3f (p->data[9] , p->data[10], p->data[11]); - } - qglEnd(); + qglEnd(); + CHECKGLERROR + } } } @@ -2957,12 +3109,12 @@ void VM_R_PolygonBegin (void) 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) { - p = Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t)); + p = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t)); memset(p, 0, 2 * vm_polygons_num * sizeof(vm_polygon_t)); memcpy(p, vm_polygons, vm_polygons_num * sizeof(vm_polygon_t)); Mem_Free(vm_polygons); @@ -2974,7 +3126,7 @@ void VM_R_PolygonBegin (void) 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; @@ -2999,7 +3151,7 @@ void VM_R_PolygonVertex (void) 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); @@ -3010,14 +3162,13 @@ void VM_R_PolygonVertex (void) 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)) @@ -3041,9 +3192,10 @@ void VM_R_PolygonEnd (void) { 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 @@ -3052,20 +3204,119 @@ void VM_R_PolygonEnd (void) 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) { - unsigned int i; + int i; if(!vm_drawpolygons_num) return; - for(i = 0;i < vm_drawpolygons_num;i++) - R_MeshQueue_Add(VM_DrawPolygonCallback, NULL, i, NULL); + R_Mesh_Matrix(&identitymatrix); + GL_CullFace(GL_NONE); + for(i = 0;i < (int)vm_drawpolygons_num;i++) + VM_DrawPolygonCallback(NULL, NULL, 1, &i); vm_drawpolygons_num = 0; } +void Debug_PolygonBegin(const char *picname, int flags, qboolean draw2d, float linewidth) +{ + vm_polygon_t *p; + + if(!vm_polygons_initialized) + VM_InitPolygons(); + if(vm_polygonbegin) + { + Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n"); + return; + } + // limit polygons to a vaguely sane amount, beyond this each one just + // replaces the last one + vm_drawpolygons_num = min(vm_drawpolygons_num, (1<<20)-1); + if(vm_drawpolygons_num >= vm_polygons_num) + { + p = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t)); + memset(p, 0, 2 * vm_polygons_num * sizeof(vm_polygon_t)); + memcpy(p, vm_polygons, vm_polygons_num * sizeof(vm_polygon_t)); + Mem_Free(vm_polygons); + vm_polygons = p; + vm_polygons_num *= 2; + } + p = &vm_polygons[vm_drawpolygons_num]; + if(picname && picname[0]) + p->tex = Draw_CachePic(picname, true)->tex; + else + p->tex = r_texture_white; + p->flags = flags; + vm_current_vertices = 0; + vm_polygonbegin = true; + if(draw2d) + p->flags |= VM_POLYGON_FL2D; + if(linewidth) + { + p->data[13] = linewidth; //[515]: linewidth + p->flags |= VM_POLYGON_FLLINES; + } +} + +void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a) +{ + vm_polygon_t *p; + + if(!vm_polygonbegin) + { + Con_Printf("Debug_PolygonVertex: Debug_PolygonBegin wasn't called\n"); + return; + } + + p = &vm_polygons[vm_drawpolygons_num]; + if(vm_current_vertices > 4) + { + Con_Printf("Debug_PolygonVertex: may have 4 vertices max\n"); + return; + } + + p->data[vm_current_vertices*3] = x; + p->data[1+vm_current_vertices*3] = y; + p->data[2+vm_current_vertices*3] = z; + + p->data[12+vm_current_vertices*2] = s; + if(!(p->flags & VM_POLYGON_FLLINES)) + p->data[13+vm_current_vertices*2] = t; + + p->data[20+vm_current_vertices*4] = r; + p->data[21+vm_current_vertices*4] = g; + p->data[22+vm_current_vertices*4] = b; + p->data[23+vm_current_vertices*4] = a; + + vm_current_vertices++; + if(vm_current_vertices == 4) + p->flags |= VM_POLYGON_FL4V; + else + if(vm_current_vertices == 3) + p->flags |= VM_POLYGON_FL3V; +} + +void Debug_PolygonEnd(void) +{ + if(!vm_polygonbegin) + { + Con_Printf("Debug_PolygonEnd: Debug_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_AddPolygonTo2DScene(&vm_polygons[vm_drawpolygons_num]); + else + vm_drawpolygons_num++; + } + else + Con_Printf("Debug_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices); +} + + @@ -3129,17 +3380,16 @@ string altstr_prepare(string) */ void VM_altstr_prepare( void ) { - char *outstr, *out; + char *out; const char *instr, *in; int size; + char outstr[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT( 1, VM_altstr_prepare ); instr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( instr ); - outstr = VM_GetTempString(); - for( out = outstr, in = instr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *in ; size--, in++, out++ ) + for( out = outstr, in = instr, size = sizeof(outstr) - 1 ; size && *in ; size--, in++, out++ ) if( *in == '\'' ) { *out++ = '\\'; *out = '\''; @@ -3148,7 +3398,7 @@ void VM_altstr_prepare( void ) *out = *in; *out = 0; - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -3161,15 +3411,15 @@ string altstr_get(string, float) void VM_altstr_get( void ) { const char *altstr, *pos; - char *outstr, *out; + char *out; int count, size; + char outstr[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT( 2, VM_altstr_get ); altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); - count = PRVM_G_FLOAT( OFS_PARM1 ); + count = (int)PRVM_G_FLOAT( OFS_PARM1 ); count = count * 2 + 1; for( pos = altstr ; *pos && count ; pos++ ) @@ -3180,12 +3430,11 @@ void VM_altstr_get( void ) count--; if( !*pos ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL ); + PRVM_G_INT( OFS_RETURN ) = 0; return; } - outstr = VM_GetTempString(); - for( out = outstr, size = VM_STRINGTEMP_LENGTH - 1 ; size && *pos ; size--, pos++, out++ ) + for( out = outstr, size = sizeof(outstr) - 1 ; size && *pos ; size--, pos++, out++ ) if( *pos == '\\' ) { if( !*++pos ) break; @@ -3197,7 +3446,7 @@ void VM_altstr_get( void ) *out = *pos; *out = 0; - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -3212,19 +3461,18 @@ void VM_altstr_set( void ) int num; const char *altstr, *str; const char *in; - char *outstr, *out; + char *out; + char outstr[VM_STRINGTEMP_LENGTH]; VM_SAFEPARMCOUNT( 3, VM_altstr_set ); altstr = PRVM_G_STRING( OFS_PARM0 ); - //VM_CheckEmptyString( altstr ); - num = PRVM_G_FLOAT( OFS_PARM1 ); + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); str = PRVM_G_STRING( OFS_PARM2 ); - //VM_CheckEmptyString( str ); - outstr = out = VM_GetTempString(); + out = outstr; for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ ) if( *in == '\\' ) { if( !*++in ) { @@ -3234,10 +3482,6 @@ void VM_altstr_set( void ) num--; } - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( altstr ); - return; - } // copy set in for( ; *str; *out++ = *str++ ); // now jump over the old content @@ -3245,13 +3489,8 @@ void VM_altstr_set( void ) if( *in == '\'' || (*in == '\\' && !*++in) ) break; - if( !in ) { - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( NULL ); - return; - } - - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } /* @@ -3268,14 +3507,14 @@ void VM_altstr_ins(void) const char *set; const char *instr; const char *in; - char *outstr; char *out; + char outstr[VM_STRINGTEMP_LENGTH]; in = instr = PRVM_G_STRING( OFS_PARM0 ); - num = PRVM_G_FLOAT( OFS_PARM1 ); + num = (int)PRVM_G_FLOAT( OFS_PARM1 ); set = setstr = PRVM_G_STRING( OFS_PARM2 ); - out = outstr = VM_GetTempString(); + out = outstr; for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ ) if( *in == '\\' ) { if( !*++in ) { @@ -3289,8 +3528,8 @@ void VM_altstr_ins(void) for( ; *set ; *out++ = *set++ ); *out++ = '\''; - strcpy( out, in ); - PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr ); + strlcpy(out, in, outstr + sizeof(outstr) - out); + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( outstr ); } @@ -3322,7 +3561,7 @@ static int BufStr_FindFreeBuffer (void) for(i=0;inum_strings;i++) if(b->strings[i]) - free(b->strings[i]); + Z_Free(b->strings[i]); num_qcstringbuffers--; } - free(qcstringbuffers[index]); + Z_Free(qcstringbuffers[index]); qcstringbuffers[index] = NULL; } } @@ -3426,7 +3665,7 @@ void VM_buf_del (void) 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; } } @@ -3447,7 +3686,7 @@ void VM_buf_getsize (void) 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 @@ -3470,37 +3709,39 @@ void VM_buf_copy (void) 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 = PRVM_G_FLOAT(OFS_PARM1); + 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; } BufStr_ClearBuffer(i); - qcstringbuffers[i] = malloc(sizeof(qcstrbuffer_t)); + qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t)); memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t)); b2->num_strings = b1->num_strings; for(i=0;inum_strings;i++) if(b1->strings[i] && b1->strings[i][0]) { - b2->strings[i] = 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); } } @@ -3521,15 +3762,15 @@ void VM_buf_sort (void) 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 = PRVM_G_FLOAT(OFS_PARM1); + buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1); if(buf_sortpower <= 0) buf_sortpower = 99999999; @@ -3545,7 +3786,7 @@ void VM_buf_sort (void) break; else { - free(b->strings[i]); + Z_Free(b->strings[i]); --b->num_strings; b->strings[i] = NULL; } @@ -3564,50 +3805,39 @@ string buf_implode(float bufhandle, string glue) = #465; void VM_buf_implode (void) { qcstrbuffer_t *b; - char *k; + char k[VM_STRINGTEMP_LENGTH]; const char *sep; int i; size_t l; VM_SAFEPARMCOUNT(2, VM_buf_implode); b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)); - PRVM_G_INT(OFS_RETURN) = 0; + PRVM_G_INT(OFS_RETURN) = OFS_NULL; 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) return; sep = PRVM_G_STRING(OFS_PARM1); - k = VM_GetTempString(); k[0] = 0; for(l=i=0;inum_strings;i++) if(b->strings[i]) { - l += strlen(b->strings[i]); - if(l>=4095) - break; - k = strcat(k, b->strings[i]); - if(!k) + l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]); + if (l >= sizeof(k) - 1) break; - if(sep && (i != b->num_strings-1)) - { - l += strlen(sep); - if(l>=4095) - break; - k = strcat(k, sep); - if(!k) - break; - } + strlcat(k, sep, sizeof(k)); + strlcat(k, b->strings[i], sizeof(k)); } - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(k); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k); } /* ======================== VM_bufstr_get -get a string from buffer, returns direct pointer, dont str_unzone it! +get a string from buffer, returns tempstring, dont str_unzone it! string bufstr_get(float bufhandle, float string_index) = #465; ======================== */ @@ -3617,23 +3847,23 @@ void VM_bufstr_get (void) int strindex; VM_SAFEPARMCOUNT(2, VM_bufstr_get); + PRVM_G_INT(OFS_RETURN) = OFS_NULL; 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; if(b->num_strings <= strindex) return; if(b->strings[strindex]) - PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(b->strings[strindex]); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]); } /* @@ -3648,32 +3878,29 @@ void VM_bufstr_set (void) int bufindex, strindex; qcstrbuffer_t *b; const char *news; + size_t alloclen; VM_SAFEPARMCOUNT(3, VM_bufstr_set); - bufindex = PRVM_G_FLOAT(OFS_PARM0); + bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); 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 = PRVM_G_FLOAT(OFS_PARM1); + 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); - return; - } if(b->strings[strindex]) - free(b->strings[strindex]); - b->strings[strindex] = malloc(strlen(news)+1); - strcpy(b->strings[strindex], news); + Z_Free(b->strings[strindex]); + alloclen = strlen(news) + 1; + b->strings[strindex] = (char *)Z_Malloc(alloclen); + memcpy(b->strings[strindex], news, alloclen); } /* @@ -3689,25 +3916,20 @@ void VM_bufstr_add (void) int bufindex, order, strindex; qcstrbuffer_t *b; const char *string; + size_t alloclen; VM_SAFEPARMCOUNT(3, VM_bufstr_add); - bufindex = PRVM_G_FLOAT(OFS_PARM0); + bufindex = (int)PRVM_G_FLOAT(OFS_PARM0); b = BUFSTR_BUFFER(bufindex); 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); - return; - } - - order = PRVM_G_FLOAT(OFS_PARM2); + order = (int)PRVM_G_FLOAT(OFS_PARM2); if(order) strindex = b->num_strings; else @@ -3715,7 +3937,7 @@ void VM_bufstr_add (void) 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; } } @@ -3724,16 +3946,17 @@ void VM_bufstr_add (void) { 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; b->num_strings++; } if(b->strings[strindex]) - free(b->strings[strindex]); - b->strings[strindex] = malloc(strlen(string)+1); - strcpy(b->strings[strindex], string); + Z_Free(b->strings[strindex]); + alloclen = strlen(string) + 1; + b->strings[strindex] = (char *)Z_Malloc(alloclen); + memcpy(b->strings[strindex], string, alloclen); PRVM_G_FLOAT(OFS_RETURN) = strindex; } @@ -3753,17 +3976,17 @@ void VM_bufstr_free (void) 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 = PRVM_G_FLOAT(OFS_PARM1); + 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]) - free(b->strings[i]); + Z_Free(b->strings[i]); b->strings[i] = NULL; if(i+1 == b->num_strings) --b->num_strings;