// cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
// also applies here
+#include "quakedef.h"
+
#include "prvm_cmds.h"
#include <time.h>
+extern cvar_t prvm_backtraceforwarnings;
+
// 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];
+ static double recursive = -1;
va_start(argptr,fmt);
dpvsnprintf(msg,sizeof(msg),fmt,argptr);
va_end(argptr);
- Con_Print(msg);
+ Con_Printf(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();
+ if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
+ {
+ recursive = realtime;
+ PRVM_PrintState();
+ recursive = -1;
+ }
}
=================
VM_vectoangles
-vector vectoangles(vector)
+vector vectoangles(vector[, vector])
=================
*/
void VM_vectoangles (void)
{
- float *value1;
- float forward;
- float yaw, pitch;
-
- VM_SAFEPARMCOUNT(1,VM_vectoangles);
-
- value1 = PRVM_G_VECTOR(OFS_PARM0);
-
- if (value1[1] == 0 && value1[0] == 0)
- {
- yaw = 0;
- if (value1[2] > 0)
- pitch = 90;
- else
- pitch = 270;
- }
- else
- {
- // LordHavoc: optimized a bit
- if (value1[0])
- {
- yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
- if (yaw < 0)
- yaw += 360;
- }
- else if (value1[1] > 0)
- yaw = 90;
- else
- yaw = 270;
-
- forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
- pitch = (atan2(value1[2], forward) * 180 / M_PI);
- if (pitch < 0)
- pitch += 360;
- }
+ VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles);
- PRVM_G_FLOAT(OFS_RETURN+0) = pitch;
- PRVM_G_FLOAT(OFS_RETURN+1) = yaw;
- PRVM_G_FLOAT(OFS_RETURN+2) = 0;
+ AnglesFromVectors(PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_PARM0), prog->argc >= 2 ? PRVM_G_VECTOR(OFS_PARM1) : NULL, true);
}
/*
PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
}
+/*
+=================
+VM_cvar
+
+float cvar_type (string)
+float CVAR_TYPEFLAG_EXISTS = 1;
+float CVAR_TYPEFLAG_SAVED = 2;
+float CVAR_TYPEFLAG_PRIVATE = 4;
+float CVAR_TYPEFLAG_ENGINE = 8;
+float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
+=================
+*/
+void VM_cvar_type (void)
+{
+ char string[VM_STRINGTEMP_LENGTH];
+ cvar_t *cvar;
+ int ret;
+
+ VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
+ VM_VarString(0, string, sizeof(string));
+ VM_CheckEmptyString(string);
+ cvar = Cvar_FindVar(string);
+
+
+ if(!cvar)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ return; // CVAR_TYPE_NONE
+ }
+
+ ret = 1; // CVAR_EXISTS
+ if(cvar->flags & CVAR_SAVE)
+ ret |= 2; // CVAR_TYPE_SAVED
+ if(cvar->flags & CVAR_PRIVATE)
+ ret |= 4; // CVAR_TYPE_PRIVATE
+ if(!(cvar->flags & CVAR_ALLOCATED))
+ ret |= 8; // CVAR_TYPE_ENGINE
+ if(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string
+ ret |= 16; // CVAR_TYPE_HASDESCRIPTION
+
+ PRVM_G_FLOAT(OFS_RETURN) = ret;
+}
+
/*
=================
VM_cvar_string
VM_SAFEPARMCOUNT(1,VM_fgets);
+ // set the return value regardless of any possible errors
+ PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+
filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
{
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
if (c >= 0 || end)
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
- else
- PRVM_G_INT(OFS_RETURN) = OFS_NULL;
}
/*
void VM_tokenize (void)
{
const char *p;
+ static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNT(1,VM_tokenize);
- p = PRVM_G_STRING(OFS_PARM0);
+ strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
+ p = string;
num_tokens = 0;
while(COM_ParseToken_VM_Tokenize(&p, false))
const char *p;
const char *token;
char tokentext[MAX_INPUTLINE];
+ static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
- p = PRVM_G_STRING(OFS_PARM0);
+ strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
+ p = string;
numseparators = 0;;
for (j = 1;j < prog->argc;j++)
{
VM_SAFEPARMCOUNT(0,VM_clientstate);
- PRVM_G_FLOAT(OFS_RETURN) = cls.state;
+
+ switch( cls.state ) {
+ case ca_uninitialized:
+ case ca_dedicated:
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ break;
+ case ca_disconnected:
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+ break;
+ case ca_connected:
+ PRVM_G_FLOAT(OFS_RETURN) = 2;
+ break;
+ default:
+ // should never be reached!
+ break;
+ }
}
/*
VM_CheckEmptyString (s);
// AK Draw_CachePic is supposed to always return a valid pointer
- if( Draw_CachePic(s, false)->tex == r_texture_notexture )
+ if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture )
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
}
Draw_FreePic(s);
}
+dp_font_t *getdrawfont()
+{
+ if(prog->globaloffsets.drawfont >= 0)
+ {
+ int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+ if(f < 0 || f >= MAX_FONTS)
+ return FONT_DEFAULT;
+ return &dp_fonts[f];
+ }
+ else
+ return FONT_DEFAULT;
+}
+
/*
=========
VM_drawcharacter
return;
}
- DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
if(pos[2] || scale[2])
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, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
color = -1;
- DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false);
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
/*
string = PRVM_G_STRING(OFS_PARM0);
colors = (int)PRVM_G_FLOAT(OFS_PARM1);
- PRVM_G_FLOAT(OFS_RETURN) = DrawQ_String(0, 0, string, 0, 1, 1, 0, 0, 0, 0, 0, NULL, !colors); // 1x1 characters, don't actually draw
+ PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
}
/*
=========
if(pos[2] || size[2])
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);
+ DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
/*
if(pos[2] || size[2])
Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
- DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic(picname, true),
+ DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname),
size[0], size[1],
srcPos[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
srcPos[0] + srcSize[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
p = PRVM_G_STRING(OFS_PARM0);
VM_CheckEmptyString (p);
- pic = Draw_CachePic (p, false);
+ pic = Draw_CachePic_Flags (p, CACHEPICFLAG_NOTPERSISTENT);
PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
CL_RestartVideo( video );
}
+/*
+========================
+VM_Gecko_Init
+========================
+*/
+void VM_Gecko_Init( void ) {
+ // the prog struct is memset to 0 by Initprog? [12/6/2007 Black]
+ // FIXME: remove the other _Init functions then, too? [12/6/2007 Black]
+}
+
+/*
+========================
+VM_Gecko_Destroy
+========================
+*/
+void VM_Gecko_Destroy( void ) {
+ int i;
+ for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
+ clgecko_t **instance = &prog->opengeckoinstances[ i ];
+ if( *instance ) {
+ CL_Gecko_DestroyBrowser( *instance );
+ }
+ *instance = NULL;
+ }
+}
+
+/*
+========================
+VM_gecko_create
+
+float[bool] gecko_create( string name )
+========================
+*/
+void VM_gecko_create( void ) {
+ const char *name;
+ int i;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_create );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ // find an empty slot for this gecko browser..
+ for( i = 0 ; i < PRVM_MAX_GECKOINSTANCES ; i++ ) {
+ if( prog->opengeckoinstances[ i ] == NULL ) {
+ break;
+ }
+ }
+ if( i == PRVM_MAX_GECKOINSTANCES ) {
+ VM_Warning("VM_gecko_create: %s ran out of gecko handles (%i)\n", PRVM_NAME, PRVM_MAX_GECKOINSTANCES);
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ instance = prog->opengeckoinstances[ i ] = CL_Gecko_CreateBrowser( name, PRVM_GetProgNr() );
+ if( !instance ) {
+ // TODO: error handling [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+ PRVM_G_FLOAT( OFS_RETURN ) = 1;
+}
+
+/*
+========================
+VM_gecko_destroy
+
+void gecko_destroy( string name )
+========================
+*/
+void VM_gecko_destroy( void ) {
+ const char *name;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_destroy );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_DestroyBrowser( instance );
+}
+
+/*
+========================
+VM_gecko_navigate
+
+void gecko_navigate( string name, string URI )
+========================
+*/
+void VM_gecko_navigate( void ) {
+ const char *name;
+ const char *URI;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 2, VM_gecko_navigate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ URI = PRVM_G_STRING( OFS_PARM1 );
+ VM_CheckEmptyString( name );
+ VM_CheckEmptyString( URI );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_NavigateToURI( instance, URI );
+}
+
+/*
+========================
+VM_gecko_keyevent
+
+float[bool] gecko_keyevent( string name, float key, float eventtype )
+========================
+*/
+void VM_gecko_keyevent( void ) {
+ const char *name;
+ unsigned int key;
+ clgecko_buttoneventtype_t eventtype;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 );
+ switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM2 ) ) {
+ case 0:
+ eventtype = CLG_BET_DOWN;
+ break;
+ case 1:
+ eventtype = CLG_BET_UP;
+ break;
+ case 2:
+ eventtype = CLG_BET_PRESS;
+ break;
+ case 3:
+ eventtype = CLG_BET_DOUBLECLICK;
+ break;
+ default:
+ // TODO: console printf? [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+}
+
+/*
+========================
+VM_gecko_movemouse
+
+void gecko_mousemove( string name, float x, float y )
+========================
+*/
+void VM_gecko_movemouse( void ) {
+ const char *name;
+ float x, y;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ x = PRVM_G_FLOAT( OFS_PARM1 );
+ y = PRVM_G_FLOAT( OFS_PARM2 );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_Event_CursorMove( instance, x, y );
+}
+
+
+/*
+========================
+VM_gecko_resize
+
+void gecko_resize( string name, float w, float h )
+========================
+*/
+void VM_gecko_resize( void ) {
+ const char *name;
+ float w, h;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ w = PRVM_G_FLOAT( OFS_PARM1 );
+ h = PRVM_G_FLOAT( OFS_PARM2 );
+
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_Resize( instance, w, h );
+}
+
+
+/*
+========================
+VM_gecko_get_texture_extent
+
+vector gecko_get_texture_extent( string name )
+========================
+*/
+void VM_gecko_get_texture_extent( void ) {
+ const char *name;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+ instance = CL_Gecko_FindBrowser( name );
+ if( !instance ) {
+ PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
+ PRVM_G_VECTOR(OFS_RETURN)[1] = 0;
+ return;
+ }
+ CL_Gecko_GetTextureExtent( instance,
+ PRVM_G_VECTOR(OFS_RETURN), PRVM_G_VECTOR(OFS_RETURN)+1 );
+}
+
+
+
/*
==============
VM_makevectors
DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
}
-
-
-
-
// float(float number, float quantity) bitshift (EXT_BITSHIFT)
void VM_bitshift (void)
{
// BufString functions
////////////////////////////////////////
//[515]: string buffers support
-#define MAX_QCSTR_BUFFERS 128
-#define MAX_QCSTR_STRINGS 1024
-
-typedef struct
-{
- int num_strings;
- char *strings[MAX_QCSTR_STRINGS];
-}qcstrbuffer_t;
-
-// FIXME: move stringbuffers to prog_t to allow multiple progs!
-static qcstrbuffer_t *qcstringbuffers[MAX_QCSTR_BUFFERS];
-static int num_qcstringbuffers;
-static int buf_sortpower;
-#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a])
-#define BUFSTR_ISFREE(a) (a<MAX_QCSTR_BUFFERS&&qcstringbuffers[a]&&qcstringbuffers[a]->num_strings<=0) ? 1 : 0
+static size_t stringbuffers_sortlength;
-static int BufStr_FindFreeBuffer (void)
+static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex)
{
- int i;
- if(num_qcstringbuffers == MAX_QCSTR_BUFFERS)
- return -1;
- for(i=0;i<MAX_QCSTR_BUFFERS;i++)
- if(!qcstringbuffers[i])
- {
- qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
- memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
- return i;
- }
- return -1;
+ if (stringbuffer->max_strings <= strindex)
+ {
+ char **oldstrings = stringbuffer->strings;
+ stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
+ while (stringbuffer->max_strings <= strindex)
+ stringbuffer->max_strings *= 2;
+ stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
+ if (stringbuffer->num_strings > 0)
+ memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
+ if (oldstrings)
+ Mem_Free(oldstrings);
+ }
}
-static void BufStr_ClearBuffer (int index)
+static void BufStr_Shrink(prvm_stringbuffer_t *stringbuffer)
{
- qcstrbuffer_t *b = qcstringbuffers[index];
- int i;
+ // reduce num_strings if there are empty string slots at the end
+ while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL)
+ stringbuffer->num_strings--;
- if(b)
+ // if empty, free the string pointer array
+ if (stringbuffer->num_strings == 0)
{
- if(b->num_strings > 0)
- {
- for(i=0;i<b->num_strings;i++)
- if(b->strings[i])
- Z_Free(b->strings[i]);
- num_qcstringbuffers--;
- }
- Z_Free(qcstringbuffers[index]);
- qcstringbuffers[index] = NULL;
+ stringbuffer->max_strings = 0;
+ if (stringbuffer->strings)
+ Mem_Free(stringbuffer->strings);
+ stringbuffer->strings = NULL;
}
}
-static int BufStr_FindFreeString (qcstrbuffer_t *b)
-{
- int i;
- for(i=0;i<b->num_strings;i++)
- if(!b->strings[i] || !b->strings[i][0])
- return i;
- if(i == MAX_QCSTR_STRINGS) return -1;
- else return i;
-}
-
static int BufStr_SortStringsUP (const void *in1, const void *in2)
{
const char *a, *b;
b = *((const char **) in2);
if(!a[0]) return 1;
if(!b[0]) return -1;
- return strncmp(a, b, buf_sortpower);
+ return strncmp(a, b, stringbuffers_sortlength);
}
static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
b = *((const char **) in2);
if(!a[0]) return 1;
if(!b[0]) return -1;
- return strncmp(b, a, buf_sortpower);
+ return strncmp(b, a, stringbuffers_sortlength);
}
/*
*/
void VM_buf_create (void)
{
+ prvm_stringbuffer_t *stringbuffer;
int i;
VM_SAFEPARMCOUNT(0, VM_buf_create);
- i = BufStr_FindFreeBuffer();
- if(i >= 0)
- num_qcstringbuffers++;
- //else
- //Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME);
+ stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
+ for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
PRVM_G_FLOAT(OFS_RETURN) = i;
}
*/
void VM_buf_del (void)
{
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(1, VM_buf_del);
- if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)))
- BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if (stringbuffer)
+ {
+ int i;
+ for (i = 0;i < stringbuffer->num_strings;i++)
+ if (stringbuffer->strings[i])
+ Mem_Free(stringbuffer->strings[i]);
+ if (stringbuffer->strings)
+ Mem_Free(stringbuffer->strings);
+ Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
+ }
else
{
VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
*/
void VM_buf_getsize (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(1, VM_buf_getsize);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
else
- PRVM_G_FLOAT(OFS_RETURN) = b->num_strings;
+ PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings;
}
/*
*/
void VM_buf_copy (void)
{
- qcstrbuffer_t *b1, *b2;
- int i;
+ prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer;
+ int i;
VM_SAFEPARMCOUNT(2, VM_buf_copy);
- b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b1)
+ srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!srcstringbuffer)
{
VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
return;
}
- b2 = BUFSTR_BUFFER(i);
- if(!b2)
+ dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!dststringbuffer)
{
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] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
- memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
- b2->num_strings = b1->num_strings;
+ for (i = 0;i < dststringbuffer->num_strings;i++)
+ if (dststringbuffer->strings[i])
+ Mem_Free(dststringbuffer->strings[i]);
+ if (dststringbuffer->strings)
+ Mem_Free(dststringbuffer->strings);
+ *dststringbuffer = *srcstringbuffer;
+ if (dststringbuffer->max_strings)
+ dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings);
- for(i=0;i<b1->num_strings;i++)
- if(b1->strings[i] && b1->strings[i][0])
+ for (i = 0;i < dststringbuffer->num_strings;i++)
+ {
+ if (srcstringbuffer->strings[i])
{
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;
- }
- memcpy(b2->strings[i], b1->strings[i], stringlen);
+ stringlen = strlen(srcstringbuffer->strings[i]) + 1;
+ dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen);
+ memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen);
}
+ }
}
/*
========================
VM_buf_sort
-sort buffer by beginnings of strings (sortpower defaults it's lenght)
+sort buffer by beginnings of strings (cmplength defaults it's length)
"backward == TRUE" means that sorting goes upside-down
-void buf_sort(float bufhandle, float sortpower, float backward) = #464;
+void buf_sort(float bufhandle, float cmplength, float backward) = #464;
========================
*/
void VM_buf_sort (void)
{
- qcstrbuffer_t *b;
- int i;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(3, VM_buf_sort);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
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)
+ if(stringbuffer->num_strings <= 0)
{
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);
- if(buf_sortpower <= 0)
- buf_sortpower = 99999999;
+ stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1);
+ if(stringbuffers_sortlength <= 0)
+ stringbuffers_sortlength = 0x7FFFFFFF;
if(!PRVM_G_FLOAT(OFS_PARM2))
- qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP);
+ qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP);
else
- qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
+ qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
- for(i=b->num_strings-1;i>=0;i--) //[515]: delete empty lines
- if(b->strings)
- {
- if(b->strings[i][0])
- break;
- else
- {
- Z_Free(b->strings[i]);
- --b->num_strings;
- b->strings[i] = NULL;
- }
- }
- else
- --b->num_strings;
+ BufStr_Shrink(stringbuffer);
}
/*
*/
void VM_buf_implode (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
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));
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
- if(!b)
+ if(!stringbuffer)
{
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)
+ if(!stringbuffer->num_strings)
return;
sep = PRVM_G_STRING(OFS_PARM1);
k[0] = 0;
- for(l=i=0;i<b->num_strings;i++)
- if(b->strings[i])
+ for(l = i = 0;i < stringbuffer->num_strings;i++)
+ {
+ if(stringbuffer->strings[i])
{
- l += (i > 0 ? strlen(sep) : 0) + strlen(b->strings[i]);
+ l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]);
if (l >= sizeof(k) - 1)
break;
strlcat(k, sep, sizeof(k));
- strlcat(k, b->strings[i], sizeof(k));
+ strlcat(k, stringbuffer->strings[i], sizeof(k));
}
+ }
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(k);
}
*/
void VM_bufstr_get (void)
{
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
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)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
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)
+ if (strindex < 0)
{
VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
- if(b->num_strings <= strindex)
- return;
- if(b->strings[strindex])
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(b->strings[strindex]);
+ if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex])
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(stringbuffer->strings[strindex]);
}
/*
*/
void VM_bufstr_set (void)
{
- int bufindex, strindex;
- qcstrbuffer_t *b;
+ int strindex;
+ prvm_stringbuffer_t *stringbuffer;
const char *news;
- size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_set);
- bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
- b = BUFSTR_BUFFER(bufindex);
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
- VM_Warning("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", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
- if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+ if(strindex < 0 || strindex >= 1000000) // huge number of strings
{
VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
+
+ BufStr_Expand(stringbuffer, strindex);
+ stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
+
+ if(stringbuffer->strings[strindex])
+ Mem_Free(stringbuffer->strings[strindex]);
+ stringbuffer->strings[strindex] = NULL;
+
news = PRVM_G_STRING(OFS_PARM2);
- if(b->strings[strindex])
- Z_Free(b->strings[strindex]);
- alloclen = strlen(news) + 1;
- b->strings[strindex] = (char *)Z_Malloc(alloclen);
- memcpy(b->strings[strindex], news, alloclen);
+ if (news && news[0])
+ {
+ size_t alloclen = strlen(news) + 1;
+ stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+ memcpy(stringbuffer->strings[strindex], news, alloclen);
+ }
+
+ BufStr_Shrink(stringbuffer);
}
/*
========================
VM_bufstr_add
-adds string to buffer in nearest free slot and returns it
+adds string to buffer in first free slot and returns its index
"order == TRUE" means that string will be added after last "full" slot
float bufstr_add(float bufhandle, string str, float order) = #467;
========================
*/
void VM_bufstr_add (void)
{
- int bufindex, order, strindex;
- qcstrbuffer_t *b;
+ int order, strindex;
+ prvm_stringbuffer_t *stringbuffer;
const char *string;
size_t alloclen;
VM_SAFEPARMCOUNT(3, VM_bufstr_add);
- bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
- b = BUFSTR_BUFFER(bufindex);
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
PRVM_G_FLOAT(OFS_RETURN) = -1;
- if(!b)
+ if(!stringbuffer)
{
- VM_Warning("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", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
string = PRVM_G_STRING(OFS_PARM1);
+ if(!string || !string[0])
+ {
+ VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ return;
+ }
order = (int)PRVM_G_FLOAT(OFS_PARM2);
if(order)
- strindex = b->num_strings;
+ strindex = stringbuffer->num_strings;
else
- {
- strindex = BufStr_FindFreeString(b);
- if(strindex < 0)
- {
- VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
- return;
- }
- }
+ for (strindex = 0;strindex < stringbuffer->num_strings;strindex++)
+ if (stringbuffer->strings[strindex] == NULL)
+ break;
- while(b->num_strings <= strindex)
- {
- if(b->num_strings == MAX_QCSTR_STRINGS)
- {
- 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])
- Z_Free(b->strings[strindex]);
+ BufStr_Expand(stringbuffer, strindex);
+
+ stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
alloclen = strlen(string) + 1;
- b->strings[strindex] = (char *)Z_Malloc(alloclen);
- memcpy(b->strings[strindex], string, alloclen);
+ stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+ memcpy(stringbuffer->strings[strindex], string, alloclen);
+
PRVM_G_FLOAT(OFS_RETURN) = strindex;
}
void VM_bufstr_free (void)
{
int i;
- qcstrbuffer_t *b;
+ prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNT(2, VM_bufstr_free);
- b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
- if(!b)
+ stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+ if(!stringbuffer)
{
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)
+ if(i < 0)
{
VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
return;
}
- if(b->strings[i])
- Z_Free(b->strings[i]);
- b->strings[i] = NULL;
- if(i+1 == b->num_strings)
- --b->num_strings;
+
+ if (i < stringbuffer->num_strings)
+ {
+ if(stringbuffer->strings[i])
+ Mem_Free(stringbuffer->strings[i]);
+ stringbuffer->strings[i] = NULL;
+ }
+
+ BufStr_Shrink(stringbuffer);
}
//=============
PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move);
}
-
+// TODO: adapt all static function names to use a single naming convention... [12/3/2007 Black]
static int Is_Text_Color (char c, char t)
{
int a = 0;
}
}
+// #494 float(float caseinsensitive, string s, ...) crc16
+void VM_crc16(void)
+{
+ float insensitive;
+ static char s[VM_STRINGTEMP_LENGTH];
+ VM_SAFEPARMCOUNTRANGE(2, 8, VM_hash);
+ insensitive = PRVM_G_FLOAT(OFS_PARM0);
+ VM_VarString(1, s, sizeof(s));
+ PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s)));
+}
+
void VM_wasfreed (void)
{
VM_SAFEPARMCOUNT(1, VM_wasfreed);
// only init the stuff for the current prog
VM_Files_Init();
VM_Search_Init();
+ VM_Gecko_Init();
// VM_BufStr_Init();
}
CL_PurgeOwner( MENUOWNER );
VM_Search_Reset();
VM_Files_CloseAll();
+ VM_Gecko_Destroy();
// VM_BufStr_ShutDown();
}
projects / xonotic / darkplaces.git / blobdiff